gaoding-cli 1.0.0-alpha.10

package/dist/src/features/editor/bridge-process.js

@@ -0,0 +1,222 @@
+import { spawn as nodeSpawn } from "node:child_process";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { startEditorBridge } from "./bridge-server.js";
+import { createEditorSessionStateStore } from "./session-state.js";
+const DEFAULT_READINESS_TIMEOUT_MS = 10_000;
+export async function runEditorBridgeProcess(targetOrigin, options = {}) {
+    const runtime = options.runtime ?? process;
+    const store = createEditorSessionStateStore({
+        ...(options.homeDirectory === undefined
+            ? {}
+            : { homeDirectory: options.homeDirectory })
+    });
+    const bridge = await (options.startBridge ?? startEditorBridge)({ targetOrigin });
+    const shutdown = () => {
+        void bridge.close().catch(() => undefined);
+    };
+    let signalListenersInstalled = false;
+    const removeSignalListeners = () => {
+        if (!signalListenersInstalled)
+            return;
+        signalListenersInstalled = false;
+        runtime.removeListener("SIGINT", shutdown);
+        runtime.removeListener("SIGTERM", shutdown);
+    };
+    try {
+        await store.write(bridge.state);
+        runtime.once("SIGINT", shutdown);
+        runtime.once("SIGTERM", shutdown);
+        signalListenersInstalled = true;
+        await runtime.send?.({ type: "ready", state: bridge.state });
+        await runtime.disconnect?.();
+    }
+    catch (cause) {
+        removeSignalListeners();
+        await cleanupFailedBridge(bridge, store);
+        throw cause;
+    }
+    try {
+        await bridge.closed;
+    }
+    finally {
+        removeSignalListeners();
+        await store.removeIfOwned(bridge.state.token);
+    }
+}
+export function startEditorBridgeProcess(input) {
+    if (input.signal.aborted)
+        return Promise.reject(abortReason(input.signal));
+    let child;
+    try {
+        child = (input.spawn ?? nodeSpawn)(process.execPath, [
+            fileURLToPath(new URL("./bridge-process.js", import.meta.url)),
+            input.targetOrigin,
+            ...(input.homeDirectory === undefined ? [] : [input.homeDirectory])
+        ], {
+            detached: true,
+            stdio: ["ignore", "ignore", "ignore", "ipc"]
+        });
+    }
+    catch (cause) {
+        return Promise.reject(cause);
+    }
+    return awaitReadiness(child, input);
+}
+async function cleanupFailedBridge(bridge, store) {
+    try {
+        await bridge.close();
+    }
+    catch {
+        // Preserve the setup failure.
+    }
+    try {
+        await store.removeIfOwned(bridge.state.token);
+    }
+    catch {
+        // Preserve the setup failure.
+    }
+}
+function awaitReadiness(child, input) {
+    return new Promise((resolvePromise, rejectPromise) => {
+        let settled = false;
+        let timer;
+        let ipcDisconnectAttempted = false;
+        let killAttempted = false;
+        const onError = (error) => {
+            settleFailure(error);
+        };
+        const onExit = (code) => {
+            settleFailure(new Error(`Editor Bridge exited before ready (${code ?? "signal"}).`));
+        };
+        const onMessage = (message) => {
+            if (settled)
+                return;
+            const state = parseReadyMessage(message, input.targetOrigin);
+            if (!state) {
+                settleFailure(new Error("Editor Bridge sent invalid readiness."));
+                return;
+            }
+            try {
+                disconnectIpc();
+                child.unref();
+            }
+            catch (cause) {
+                settleFailure(cause);
+                return;
+            }
+            settled = true;
+            clearTimer();
+            removeSuccessListeners();
+            resolvePromise(state);
+        };
+        const onAbort = () => {
+            settleFailure(abortReason(input.signal));
+        };
+        const clearTimer = () => {
+            if (timer === undefined)
+                return;
+            clearTimeout(timer);
+            timer = undefined;
+        };
+        const disconnectIpc = () => {
+            if (ipcDisconnectAttempted || !child.connected)
+                return;
+            ipcDisconnectAttempted = true;
+            child.disconnect();
+        };
+        const cleanupFailedChild = () => {
+            child.removeListener("message", onMessage);
+            input.signal.removeEventListener("abort", onAbort);
+            try {
+                disconnectIpc();
+            }
+            catch {
+                // The IPC channel may already be unavailable.
+            }
+            if (!killAttempted) {
+                killAttempted = true;
+                try {
+                    child.kill();
+                }
+                catch {
+                    // The child may already have exited.
+                }
+            }
+        };
+        const removeSuccessListeners = () => {
+            child.removeListener("message", onMessage);
+            child.removeListener("error", onError);
+            child.removeListener("exit", onExit);
+            input.signal.removeEventListener("abort", onAbort);
+        };
+        const settleFailure = (cause) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimer();
+            cleanupFailedChild();
+            rejectPromise(cause);
+        };
+        child.on("error", onError);
+        child.on("exit", onExit);
+        child.on("message", onMessage);
+        input.signal.addEventListener("abort", onAbort, { once: true });
+        if (input.signal.aborted) {
+            settleFailure(abortReason(input.signal));
+            return;
+        }
+        timer = setTimeout(() => settleFailure(new Error("Editor Bridge readiness timed out.")), Math.max(0, input.readinessTimeoutMs ?? DEFAULT_READINESS_TIMEOUT_MS));
+    });
+}
+function parseReadyMessage(value, expectedTargetOrigin) {
+    if (!isRecord(value) || !hasExactKeys(value, ["type", "state"]) || value.type !== "ready") {
+        return null;
+    }
+    const state = value.state;
+    if (!isRecord(state) ||
+        !hasExactKeys(state, ["pid", "port", "token", "startedAt", "targetOrigin"]) ||
+        !Number.isInteger(state.pid) ||
+        state.pid <= 0 ||
+        !Number.isInteger(state.port) ||
+        state.port < 1 ||
+        state.port > 65_535 ||
+        !isNonblank(state.token) ||
+        !isNonblank(state.startedAt) ||
+        state.targetOrigin !== expectedTargetOrigin) {
+        return null;
+    }
+    return state;
+}
+function abortReason(signal) {
+    return signal.reason instanceof Error
+        ? signal.reason
+        : new DOMException("The Editor Bridge start was aborted.", "AbortError");
+}
+function isNonblank(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, keys) {
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    return actual.length === expected.length &&
+        actual.every((key, index) => key === expected[index]);
+}
+const ownPath = fileURLToPath(import.meta.url);
+if (process.argv[1] && resolve(process.argv[1]) === resolve(ownPath)) {
+    const targetOrigin = process.argv[2];
+    const homeDirectory = process.argv[3];
+    if (!targetOrigin) {
+        process.exitCode = 1;
+    }
+    else {
+        void runEditorBridgeProcess(targetOrigin, {
+            ...(homeDirectory === undefined ? {} : { homeDirectory })
+        }).catch(() => {
+            process.exitCode = 1;
+        });
+    }
+}

package/dist/src/features/editor/bridge-server.js

@@ -0,0 +1,311 @@
+import { randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { createServer } from "node:http";
+import { WebSocket, WebSocketServer } from "ws";
+import { EDITOR_PROTOCOL_VERSION } from "./protocol.js";
+export async function startEditorBridge(options) {
+    const token = options.token ?? randomBytes(32).toString("hex");
+    const now = options.now ?? (() => new Date());
+    const nextRequestId = options.requestId ?? randomUUID;
+    const webSockets = new WebSocketServer({ noServer: true });
+    let pageSocket = null;
+    let pending;
+    let closing;
+    let resolveClosed;
+    const closed = new Promise((resolve) => {
+        resolveClosed = resolve;
+    });
+    const http = createServer((request, response) => {
+        void handleRequest(request, response).catch(() => {
+            sendError(response, 500, "SERVER_ERROR", "Editor Bridge request failed.");
+        });
+    });
+    http.on("upgrade", (request, socket, head) => {
+        if (request.headers.origin !== options.targetOrigin) {
+            rejectUpgrade(socket, 403, "Forbidden");
+            return;
+        }
+        webSockets.handleUpgrade(request, socket, head, (webSocket) => {
+            webSockets.emit("connection", webSocket, request);
+        });
+    });
+    webSockets.on("connection", (socket) => {
+        let authenticated = false;
+        const handleSocketClosed = () => {
+            if (socket !== pageSocket)
+                return;
+            pageSocket = null;
+            failPending(503, "EDITOR_DISCONNECTED", "The Editor page disconnected.");
+        };
+        socket.on("message", (data) => {
+            const message = parseMessage(data.toString());
+            if (!authenticated) {
+                const connect = parseConnectMessage(message);
+                if (!connect) {
+                    closeWithError(socket, "INVALID_HANDSHAKE", "First message must authenticate.");
+                    return;
+                }
+                if (!safeEqual(connect.token, token)) {
+                    closeWithError(socket, "UNAUTHORIZED", "Editor token is invalid.");
+                    return;
+                }
+                if (connect.protocolVersion !== EDITOR_PROTOCOL_VERSION) {
+                    closeWithError(socket, "PROTOCOL_VERSION_MISMATCH", `Editor protocol version must be ${EDITOR_PROTOCOL_VERSION}.`);
+                    return;
+                }
+                if (pageSocket !== null) {
+                    closeWithError(socket, "EDITOR_ALREADY_CONNECTED", "An Editor page is already connected.");
+                    return;
+                }
+                authenticated = true;
+                pageSocket = socket;
+                sendSocket(socket, {
+                    type: "connected",
+                    protocolVersion: EDITOR_PROTOCOL_VERSION
+                });
+                return;
+            }
+            if (socket !== pageSocket)
+                return;
+            const pageResponse = parseResponseMessage(message);
+            if (!pageResponse || pageResponse.requestId !== pending?.requestId)
+                return;
+            const response = pending.response;
+            pending = undefined;
+            if (pageResponse.error) {
+                sendJson(response, 422, { error: pageResponse.error });
+            }
+            else {
+                sendJson(response, 200, { result: pageResponse.result });
+            }
+        });
+        socket.on("error", () => {
+            handleSocketClosed();
+            if (socket.readyState !== WebSocket.CLOSED)
+                socket.terminate();
+        });
+        socket.on("close", handleSocketClosed);
+    });
+    await new Promise((resolve, reject) => {
+        http.once("error", reject);
+        http.listen(0, "127.0.0.1", () => {
+            http.off("error", reject);
+            resolve();
+        });
+    });
+    const address = http.address();
+    if (!address || typeof address === "string") {
+        await close();
+        throw new Error("Editor Bridge did not bind a TCP port.");
+    }
+    const state = {
+        pid: process.pid,
+        port: address.port,
+        token,
+        startedAt: now().toISOString(),
+        targetOrigin: options.targetOrigin
+    };
+    return { state, close, closed };
+    async function handleRequest(request, response) {
+        if (!isAuthorized(request, token)) {
+            sendError(response, 401, "UNAUTHORIZED", "Editor token is invalid.");
+            return;
+        }
+        const pathname = new URL(request.url ?? "/", "http://127.0.0.1").pathname;
+        if (request.method === "GET" && pathname === "/health") {
+            sendJson(response, 200, {
+                status: "ok",
+                pageConnected: pageSocket?.readyState === WebSocket.OPEN,
+                protocolVersion: EDITOR_PROTOCOL_VERSION
+            });
+            return;
+        }
+        if (request.method === "POST" && pathname === "/rpc") {
+            if (pageSocket?.readyState !== WebSocket.OPEN) {
+                sendError(response, 409, "EDITOR_NOT_CONNECTED", "No Editor page is connected.");
+                return;
+            }
+            if (pending) {
+                sendError(response, 409, "EDITOR_BUSY", "Editor is handling another request.");
+                return;
+            }
+            const body = await readRpcBody(request).catch(() => null);
+            if (!body) {
+                sendError(response, 400, "INVALID_REQUEST", "Editor RPC body is invalid.");
+                return;
+            }
+            if (pageSocket?.readyState !== WebSocket.OPEN) {
+                sendError(response, 409, "EDITOR_NOT_CONNECTED", "No Editor page is connected.");
+                return;
+            }
+            if (pending) {
+                sendError(response, 409, "EDITOR_BUSY", "Editor is handling another request.");
+                return;
+            }
+            const requestId = nextRequestId();
+            const socket = pageSocket;
+            pending = { requestId, response };
+            const message = {
+                type: "request",
+                requestId,
+                method: body.method,
+                ...(body.payload === undefined ? {} : { payload: body.payload })
+            };
+            try {
+                socket.send(JSON.stringify(message), (error) => {
+                    if (!error || pending?.requestId !== requestId)
+                        return;
+                    pending = undefined;
+                    sendError(response, 503, "EDITOR_DISCONNECTED", "The Editor page disconnected.");
+                });
+            }
+            catch {
+                if (pending?.requestId === requestId)
+                    pending = undefined;
+                sendError(response, 503, "EDITOR_DISCONNECTED", "The Editor page disconnected.");
+            }
+            return;
+        }
+        if (request.method === "POST" && pathname === "/disconnect") {
+            sendJson(response, 200, { status: "disconnected" });
+            setImmediate(() => void close());
+            return;
+        }
+        sendError(response, 404, "NOT_FOUND", "Editor Bridge route not found.");
+    }
+    function failPending(status, code, message) {
+        if (!pending)
+            return;
+        const response = pending.response;
+        pending = undefined;
+        sendError(response, status, code, message);
+    }
+    function close() {
+        if (closing)
+            return closing;
+        closing = new Promise((resolve) => {
+            failPending(503, "SERVER_STOPPED", "Editor Bridge stopped.");
+            for (const socket of webSockets.clients)
+                socket.terminate();
+            webSockets.close();
+            http.close(() => {
+                resolve();
+                resolveClosed();
+            });
+        });
+        return closing;
+    }
+}
+function isAuthorized(request, token) {
+    const header = request.headers.authorization;
+    return typeof header === "string" && safeEqual(header, `Bearer ${token}`);
+}
+function safeEqual(actual, expected) {
+    const actualBytes = Buffer.from(actual);
+    const expectedBytes = Buffer.from(expected);
+    return actualBytes.length === expectedBytes.length &&
+        timingSafeEqual(actualBytes, expectedBytes);
+}
+function rejectUpgrade(socket, status, message) {
+    socket.end(`HTTP/1.1 ${status} ${message}\r\nConnection: close\r\nContent-Length: 0\r\n\r\n`);
+}
+function closeWithError(socket, code, message) {
+    sendSocket(socket, { type: "error", error: { code, message } }, () => socket.close());
+}
+function sendSocket(socket, value, callback) {
+    try {
+        socket.send(JSON.stringify(value), () => callback?.());
+    }
+    catch {
+        socket.terminate();
+    }
+}
+function parseMessage(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+function parseConnectMessage(value) {
+    if (!isRecord(value) || !hasExactKeys(value, ["type", "token", "protocolVersion"])) {
+        return null;
+    }
+    if (value.type !== "connect" ||
+        typeof value.token !== "string" ||
+        typeof value.protocolVersion !== "number") {
+        return null;
+    }
+    return {
+        type: "connect",
+        token: value.token,
+        protocolVersion: value.protocolVersion
+    };
+}
+function parseResponseMessage(value) {
+    if (!isRecord(value) || value.type !== "response" || typeof value.requestId !== "string") {
+        return null;
+    }
+    if (value.error !== undefined) {
+        if (!isRecord(value.error) ||
+            typeof value.error.code !== "string" ||
+            typeof value.error.message !== "string") {
+            return null;
+        }
+        return {
+            type: "response",
+            requestId: value.requestId,
+            error: {
+                code: value.error.code,
+                message: value.error.message
+            }
+        };
+    }
+    return {
+        type: "response",
+        requestId: value.requestId,
+        ...(value.result === undefined ? {} : { result: value.result })
+    };
+}
+async function readRpcBody(request) {
+    const chunks = [];
+    for await (const chunk of request) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    }
+    const value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    if (!isRecord(value) ||
+        !hasExactKeys(value, value.payload === undefined ? ["method"] : ["method", "payload"]) ||
+        !isEditorMethod(value.method)) {
+        throw new Error("invalid Editor RPC body");
+    }
+    return {
+        method: value.method,
+        ...(value.payload === undefined ? {} : { payload: value.payload })
+    };
+}
+function isEditorMethod(value) {
+    return value === "preflight" ||
+        value === "snapshot" ||
+        value === "apply" ||
+        value === "screenshot" ||
+        value === "save";
+}
+function sendError(response, status, code, message) {
+    if (!response.headersSent)
+        sendJson(response, status, { error: { code, message } });
+}
+function sendJson(response, status, value) {
+    if (response.writableEnded || response.destroyed)
+        return;
+    response.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+    response.end(JSON.stringify(value));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, keys) {
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    return actual.length === expected.length &&
+        actual.every((key, index) => key === expected[index]);
+}

package/dist/src/features/editor/protocol.js

@@ -0,0 +1 @@
+export const EDITOR_PROTOCOL_VERSION = 1;

package/dist/src/features/editor/session-state.js

@@ -0,0 +1,78 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createLocalJsonFile } from "../../platform/local-json-file.js";
+export function createEditorSessionStateStore(options = {}) {
+    const file = options.file ?? createLocalJsonFile({
+        directory: join(options.homeDirectory ?? homedir(), ".gd"),
+        filename: "editor-session.json"
+    });
+    const read = async () => {
+        const text = await file.readText();
+        if (text === null)
+            return null;
+        let value;
+        try {
+            value = JSON.parse(text);
+        }
+        catch {
+            return null;
+        }
+        return isEditorSessionState(value) ? value : null;
+    };
+    return {
+        read,
+        async write(state) {
+            await file.writeTextAtomically(`${JSON.stringify(state, null, 2)}\n`);
+        },
+        async remove() {
+            await file.remove();
+        },
+        async removeIfOwned(token) {
+            if ((await read())?.token === token)
+                await file.remove();
+        }
+    };
+}
+function isEditorSessionState(value) {
+    if (!isRecord(value))
+        return false;
+    if (!hasExactKeys(value, ["pid", "port", "token", "startedAt", "targetOrigin"])) {
+        return false;
+    }
+    return Number.isInteger(value.pid) &&
+        value.pid > 0 &&
+        Number.isInteger(value.port) &&
+        value.port >= 1 &&
+        value.port <= 65_535 &&
+        isNonblank(value.token) &&
+        isNonblank(value.startedAt) &&
+        isHttpOrigin(value.targetOrigin);
+}
+function isHttpOrigin(value) {
+    if (!isNonblank(value))
+        return false;
+    try {
+        const url = new URL(value);
+        return (url.protocol === "http:" || url.protocol === "https:") &&
+            url.username === "" &&
+            url.password === "" &&
+            url.pathname === "/" &&
+            url.search === "" &&
+            url.hash === "";
+    }
+    catch {
+        return false;
+    }
+}
+function isNonblank(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, keys) {
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    return actual.length === expected.length &&
+        actual.every((key, index) => key === expected[index]);
+}