repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/canvas/src/server.ts
Rawimport { randomBytes, timingSafeEqual } from "node:crypto";
import { readFile, realpath } from "node:fs/promises";
import {
createServer,
type IncomingMessage,
type Server,
type ServerResponse,
} from "node:http";
import { basename, dirname, extname, relative, resolve } from "node:path";
import { fileURLToPath } from "node:url";
import type { CanvasAction, CanvasState, CanvasViewport } from "./store.js";
const BODY_LIMIT = 1024 * 1024;
const MAX_CLIENTS = 8;
const PUBLISH_DELAY_MS = 100;
const JOURNAL_MAX_SNAPSHOTS = 64;
const JOURNAL_MAX_BYTES = 8 * 1024 * 1024;
const CHANGES_MAX_BYTES = 1024 * 1024;
type Client = { response: ServerResponse; blocked: boolean };
export type CanvasServer = {
url: string;
diagnostics(): { viewers: number };
publish(state: CanvasState): void;
close(): Promise<void>;
};
export async function startCanvasServer(
state: () => CanvasState,
onAction: (action: CanvasAction) => void | Promise<void>,
): Promise<CanvasServer> {
const token = randomBytes(32).toString("base64url");
const browserRoot = await browserDirectory();
const clients = new Set<Client>();
const sockets = new Set<import("node:net").Socket>();
let expectedHost = "";
const journal = createJournal(state());
let pending: CanvasState | undefined;
let timer: ReturnType<typeof setTimeout> | undefined;
let closePromise: Promise<void> | undefined;
let publish: (next: CanvasState) => void = () => undefined;
const server = createServer((req, res) => {
void dispatch(req, res, {
token,
expectedHost,
state,
onAction,
browserRoot,
clients,
publish,
journal,
}).catch((error: unknown) => {
if (!res.headersSent && !res.destroyed)
json(res, isHttpError(error) ? error.status : 400, {
error: "Invalid request.",
});
else res.destroy();
});
});
server.on("connection", (socket) => {
sockets.add(socket);
socket.once("close", () => sockets.delete(socket));
});
await listen(server);
const address = server.address();
if (!address || typeof address === "string") {
server.close();
throw new Error("Canvas loopback bind failed.");
}
expectedHost = `127.0.0.1:${address.port}`;
publish = (next: CanvasState): void => {
journal.record(next);
pending = next;
if (!timer) timer = setTimeout(flush, PUBLISH_DELAY_MS);
};
function flush(): void {
timer = undefined;
const next = pending;
pending = undefined;
if (!next) return;
let event: string;
try {
event = `event: state\ndata: ${JSON.stringify(next)}\n\n`;
} catch {
return;
}
for (const client of clients) sendEvent(client, event, clients);
}
return {
url: `http://${expectedHost}/#${token}`,
diagnostics: () => ({ viewers: clients.size }),
publish,
close(): Promise<void> {
if (closePromise) return closePromise;
if (timer) clearTimeout(timer);
timer = undefined;
pending = undefined;
for (const client of clients) client.response.end();
clients.clear();
for (const socket of sockets) socket.destroy();
closePromise = closeServer(server);
return closePromise;
},
};
}
type DispatchContext = {
token: string;
expectedHost: string;
state: () => CanvasState;
onAction: (action: CanvasAction) => void | Promise<void>;
browserRoot: string | undefined;
clients: Set<Client>;
publish: (state: CanvasState) => void;
journal: ChangeJournal;
};
async function dispatch(
req: IncomingMessage,
res: ServerResponse,
ctx: DispatchContext,
): Promise<void> {
if (req.headers.host !== ctx.expectedHost)
return json(res, 400, { error: "Invalid Host header." });
const url = new URL(req.url ?? "/", `http://${ctx.expectedHost}`);
if (url.pathname === "/")
return req.method === "GET" ? page(res) : methodNotAllowed(res, "GET");
if (url.pathname === "/layout")
return req.method === "GET"
? layoutPage(res)
: methodNotAllowed(res, "GET");
if (url.pathname === "/browser/config.js")
return req.method === "GET" ? config(res) : methodNotAllowed(res, "GET");
if (url.pathname.startsWith("/browser/"))
return serveAsset(req, res, url.pathname, ctx.browserRoot);
if (url.pathname === "/api/state") {
if (req.method !== "GET") return methodNotAllowed(res, "GET");
if (!authorized(req, ctx.token)) return unauthorized(res);
return json(res, 200, ctx.state());
}
if (url.pathname === "/api/changes") {
if (req.method !== "GET") return methodNotAllowed(res, "GET");
if (!authorized(req, ctx.token)) return unauthorized(res);
const after = cursor(url.searchParams.get("after"));
return json(res, 200, ctx.journal.changes(after, ctx.state()));
}
if (url.pathname === "/api/events") {
if (req.method !== "GET") return methodNotAllowed(res, "GET");
if (!authorized(req, ctx.token)) return unauthorized(res);
if (ctx.clients.size >= MAX_CLIENTS)
return json(res, 503, { error: "Too many canvas connections." });
return events(res, ctx.state, ctx.clients);
}
if (url.pathname === "/api/action") {
if (req.method !== "POST") return methodNotAllowed(res, "POST");
if (!authorized(req, ctx.token)) return unauthorized(res);
if (req.headers.origin !== `http://${ctx.expectedHost}`)
return json(res, 403, { error: "Invalid Origin header." });
try {
const action = validateAction(parseJson(await bodyText(req)));
await ctx.onAction(action);
const next = ctx.state();
ctx.publish(next);
return json(res, 200, { ok: true, state: next });
} catch (error) {
return json(res, isHttpError(error) ? error.status : 409, {
error: safeError(error),
});
}
}
return json(res, 404, { error: "Not found." });
}
async function browserDirectory(): Promise<string | undefined> {
const here = dirname(fileURLToPath(import.meta.url));
const candidate = resolve(
here,
basename(here) === "src" ? "../browser" : "browser",
);
try {
return await realpath(candidate);
} catch {
return undefined;
}
}
async function serveAsset(
req: IncomingMessage,
res: ServerResponse,
pathname: string,
root: string | undefined,
): Promise<void> {
if (req.method !== "GET") return methodNotAllowed(res, "GET");
if (!root) return json(res, 404, { error: "Not found." });
const name = pathname.slice("/browser/".length);
if (
!name ||
name
.split("/")
.some(
(part) =>
!/^[A-Za-z0-9._-]+$/u.test(part) || part === "." || part === "..",
)
)
return json(res, 404, { error: "Not found." });
const extension = extname(name);
if (extension !== ".js" && extension !== ".css" && extension !== ".woff2")
return json(res, 404, { error: "Not found." });
try {
const file = await realpath(resolve(root, name));
if (relative(root, file).startsWith(".."))
return json(res, 404, { error: "Not found." });
asset(res, await readFile(file), extension);
} catch {
json(res, 404, { error: "Not found." });
}
}
function validateAction(value: unknown): CanvasAction {
if (!record(value) || typeof value["kind"] !== "string")
throw requestError("Invalid action.");
switch (value["kind"]) {
case "scene":
fields(value, [
"kind",
"revision",
"elements",
"clientId",
"sequence",
"activity",
"viewport",
]);
if (!revision(value["revision"]))
throw requestError("Invalid scene revision.");
return {
kind: "scene",
revision: value["revision"],
elements: value["elements"],
clientId: identifier(value["clientId"], "client"),
sequence: sequence(value["sequence"]),
activity: activity(value["activity"]),
...(value["viewport"] === undefined
? {}
: { viewport: viewport(value["viewport"]) }),
};
case "activity":
fields(value, [
"kind",
"clientId",
"sequence",
"activity",
"revision",
"viewport",
]);
if (value["revision"] !== undefined && !revision(value["revision"]))
throw requestError("Invalid snapshot revision.");
if (value["viewport"] !== undefined && value["revision"] === undefined)
throw requestError("Snapshot image requires a revision.");
return {
kind: "activity",
clientId: identifier(value["clientId"], "client"),
sequence: sequence(value["sequence"]),
activity: activity(value["activity"]),
...(value["revision"] === undefined
? {}
: { revision: value["revision"] as number }),
...(value["viewport"] === undefined
? {}
: { viewport: viewport(value["viewport"]) }),
};
default:
throw requestError("Unknown action.");
}
}
function viewport(value: unknown): CanvasViewport {
if (!record(value)) throw requestError("Invalid viewport image.");
fields(value, [
"data",
"mimeType",
"imageWidth",
"imageHeight",
"left",
"top",
"width",
"height",
]);
const data = value["data"];
const mimeType = value["mimeType"];
if (
typeof data !== "string" ||
!data.length ||
data.length > 256 * 1024 ||
data.length % 4 !== 0 ||
!/^[A-Za-z0-9+/]+={0,2}$/u.test(data) ||
(mimeType !== "image/png" && mimeType !== "image/jpeg")
)
throw requestError("Invalid viewport image.");
const bytes = Buffer.from(data, "base64");
if (
mimeType === "image/png"
? !bytes
.subarray(0, 8)
.equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))
: bytes[0] !== 255 || bytes[1] !== 216 || bytes[2] !== 255
)
throw requestError("Invalid viewport image signature.");
for (const key of ["imageWidth", "imageHeight", "width", "height"]) {
if (typeof value[key] !== "number" || !Number.isFinite(value[key]))
throw requestError("Invalid viewport geometry.");
}
for (const key of ["imageWidth", "imageHeight"])
if (
!Number.isInteger(value[key]) ||
Number(value[key]) < 1 ||
Number(value[key]) > 1024
)
throw requestError("Invalid viewport image dimensions.");
for (const key of ["width", "height"])
if (Number(value[key]) <= 0 || Number(value[key]) > 5e7)
throw requestError("Invalid viewport dimensions.");
for (const key of ["left", "top"])
if (typeof value[key] !== "number" || !Number.isFinite(value[key]))
throw requestError("Invalid scene bounds.");
if (
Math.abs(Number(value["left"])) > 3e7 ||
Math.abs(Number(value["top"])) > 3e7
)
throw requestError("Invalid scene bounds.");
return value as CanvasViewport;
}
function fields(value: Record<string, unknown>, allowed: string[]): void {
if (Object.keys(value).some((key) => !allowed.includes(key)))
throw requestError("Action has unknown fields.");
}
function revision(value: unknown): value is number {
return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
}
function cursor(value: string | null): number {
if (value === null || !/^(?:0|[1-9][0-9]{0,15})$/u.test(value))
throw requestError("Invalid change cursor.");
const parsed = Number(value);
if (!revision(parsed)) throw requestError("Invalid change cursor.");
return parsed;
}
function sequence(value: unknown): number {
if (!revision(value)) throw requestError("Invalid activity sequence.");
return value;
}
function activity(value: unknown): "active" | "settled" | "disconnected" {
if (value !== "active" && value !== "settled" && value !== "disconnected")
throw requestError("Invalid activity state.");
return value;
}
function identifier(value: unknown, type: string): string {
if (typeof value !== "string" || !value.trim() || value.length > 120)
throw requestError(`Invalid ${type} ID.`);
return value;
}
function record(value: unknown): value is Record<string, unknown> {
return value !== null && typeof value === "object" && !Array.isArray(value);
}
function requestError(message: string): Error & { status: number } {
return Object.assign(new Error(message), { status: 400 });
}
function parseJson(value: string): unknown {
try {
return JSON.parse(value);
} catch {
throw requestError("Invalid JSON.");
}
}
function isHttpError(error: unknown): error is Error & { status: number } {
const status =
error instanceof Error ? (error as { status?: unknown }).status : undefined;
return (
typeof status === "number" &&
Number.isInteger(status) &&
status >= 400 &&
status < 500
);
}
function safeError(error: unknown): string {
if (!(error instanceof Error)) return "Action was rejected.";
const message = error.message.replace(/[\r\n\t]/gu, " ").trim();
return message && message.length <= 500 ? message : "Action was rejected.";
}
type Changes = {
currentRevision: number;
changes: CanvasState[];
nextRevision: number;
reset: boolean;
};
type JournalEntry = { state: CanvasState; bytes: number };
type ChangeJournal = {
record(state: CanvasState): void;
changes(after: number, current: CanvasState): Changes;
};
function snapshot(state: CanvasState): CanvasState {
return structuredClone(state);
}
function createJournal(initial: CanvasState): ChangeJournal {
const entries: JournalEntry[] = [];
let totalBytes = 0;
const record = (state: CanvasState): void => {
const previous = entries.at(-1)?.state;
if (previous?.revision === state.revision) return;
const copy = snapshot(state);
const bytes = Buffer.byteLength(JSON.stringify(copy));
entries.push({ state: copy, bytes });
totalBytes += bytes;
while (
entries.length > 1 &&
(entries.length > JOURNAL_MAX_SNAPSHOTS || totalBytes > JOURNAL_MAX_BYTES)
) {
const removed = entries.shift();
if (removed) totalBytes -= removed.bytes;
}
};
record(initial);
return {
record,
changes(after: number, current: CanvasState): Changes {
if (after > current.revision)
throw requestError("Invalid change cursor.");
const first = entries[0]?.state;
if (!first || after + 1 < first.revision) {
const latest = snapshot(current);
const result = {
currentRevision: latest.revision,
changes: [latest],
nextRevision: latest.revision,
reset: true,
};
if (Buffer.byteLength(JSON.stringify(result)) > CHANGES_MAX_BYTES)
throw Object.assign(
new Error("Canvas snapshot exceeds replay response limit."),
{ status: 413 },
);
return result;
}
const changes: CanvasState[] = [];
let nextRevision = after;
for (const entry of entries) {
if (entry.state.revision <= after) continue;
const candidate = [...changes, entry.state];
const result = {
currentRevision: current.revision,
changes: candidate,
nextRevision: entry.state.revision,
reset: false,
};
if (Buffer.byteLength(JSON.stringify(result)) > CHANGES_MAX_BYTES) {
if (!changes.length)
throw Object.assign(
new Error("Canvas snapshot exceeds replay response limit."),
{ status: 413 },
);
break;
}
changes.push(snapshot(entry.state));
nextRevision = entry.state.revision;
}
return {
currentRevision: current.revision,
changes,
nextRevision,
reset: false,
};
},
};
}
function events(
res: ServerResponse,
state: () => CanvasState,
clients: Set<Client>,
): void {
res.writeHead(200, {
"Content-Type": "text/event-stream",
"Cache-Control": "no-store",
Connection: "keep-alive",
"X-Content-Type-Options": "nosniff",
"Referrer-Policy": "no-referrer",
});
const client = { response: res, blocked: false };
clients.add(client);
try {
sendEvent(
client,
`event: state\ndata: ${JSON.stringify(state())}\n\n`,
clients,
);
} catch {
res.end();
}
res.once("close", () => clients.delete(client));
}
function sendEvent(client: Client, event: string, clients: Set<Client>): void {
if (client.blocked) {
client.response.destroy();
clients.delete(client);
return;
}
if (!client.response.write(event)) {
client.blocked = true;
client.response.once("drain", () => {
client.blocked = false;
});
}
}
function authorized(req: IncomingMessage, token: string): boolean {
const value = req.headers.authorization;
if (!value?.startsWith("Bearer ")) return false;
const supplied = Buffer.from(value.slice(7));
const expected = Buffer.from(token);
return (
supplied.length === expected.length && timingSafeEqual(supplied, expected)
);
}
async function bodyText(req: IncomingMessage): Promise<string> {
const chunks: Buffer[] = [];
let size = 0;
for await (const chunk of req) {
const bytes = Buffer.from(chunk);
size += bytes.length;
if (size > BODY_LIMIT)
throw Object.assign(new Error("Request body exceeds 1 MiB."), {
status: 413,
});
chunks.push(bytes);
}
return Buffer.concat(chunks).toString("utf8");
}
function page(res: ServerResponse): void {
res.writeHead(200, securityHeaders("text/html; charset=utf-8"));
res.end(
'<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>Pi canvas</title><link rel="stylesheet" href="/browser/excalidraw.css"><link rel="stylesheet" href="/browser/style.css"></head><body><div id="root"></div><script src="/browser/config.js"></script><script type="module" src="/browser/main.js"></script></body></html>',
);
}
function layoutPage(res: ServerResponse): void {
res.writeHead(200, securityHeaders("text/html; charset=utf-8"));
res.end(
'<!doctype html><html><head><meta charset="utf-8"><link rel="stylesheet" href="/browser/excalidraw.css"></head><body><script src="/browser/config.js"></script><script type="module" src="/browser/layout.js"></script></body></html>',
);
}
function config(res: ServerResponse): void {
res.writeHead(200, securityHeaders("text/javascript; charset=utf-8"));
res.end('globalThis.EXCALIDRAW_ASSET_PATH="/browser/";');
}
function json(res: ServerResponse, status: number, value: unknown): void {
res.writeHead(status, securityHeaders("application/json; charset=utf-8"));
res.end(JSON.stringify(value));
}
function unauthorized(res: ServerResponse): void {
res.writeHead(401, {
...securityHeaders("application/json; charset=utf-8"),
"WWW-Authenticate": "Bearer",
});
res.end('{"error":"Unauthorized."}');
}
function methodNotAllowed(res: ServerResponse, allow: string): void {
res.writeHead(405, {
...securityHeaders("application/json; charset=utf-8"),
Allow: allow,
});
res.end('{"error":"Method not allowed."}');
}
function asset(res: ServerResponse, body: Buffer, extension: string): void {
res.writeHead(
200,
securityHeaders(
extension === ".css"
? "text/css; charset=utf-8"
: extension === ".woff2"
? "font/woff2"
: "text/javascript; charset=utf-8",
),
);
res.end(body);
}
function securityHeaders(contentType: string): Record<string, string> {
return {
"Content-Type": contentType,
"Cache-Control": "no-store",
"Content-Security-Policy":
"default-src 'self'; base-uri 'none'; connect-src 'self'; font-src 'self' data:; img-src 'self' data: blob:; script-src 'self'; style-src 'self' 'unsafe-inline'; object-src 'none'; frame-ancestors 'none'",
"X-Content-Type-Options": "nosniff",
"Referrer-Policy": "no-referrer",
};
}
function listen(server: Server): Promise<void> {
return new Promise((resolve, reject) => {
server.once("error", reject);
server.listen(0, "127.0.0.1", () => {
server.off("error", reject);
resolve();
});
});
}
function closeServer(server: Server): Promise<void> {
return new Promise((resolve) => server.close(() => resolve()));
}