@nowcrew/daemon 0.5.31 → 0.5.32

package/dist/remote/gateway.js

@@ -1,572 +0,0 @@
-import { createReadStream } from "node:fs";
-import { access, readFile, stat } from "node:fs/promises";
-import { createServer } from "node:http";
-import { homedir } from "node:os";
-import { extname, join, normalize } from "node:path";
-import { randomUUID, timingSafeEqual } from "node:crypto";
-import { WebSocket, WebSocketServer } from "ws";
-import { ChannelToGatewaySchema, GatewayToChannelSchema, REMOTE_PROTOCOL_VERSION, ResolveRemoteApprovalSchema, ResolveRemoteQuestionSchema, SubmitRemoteInputSchema, } from "./protocol.js";
-import { RemoteSessionDiscovery } from "./session-discovery.js";
-const MAX_BODY_BYTES = 96 * 1024;
-const MAX_DEDUP_ENTRIES = 1_000;
-const WS_PROTOCOL = "nowcrew.remote.v1";
-const SESSION_PATH_RE = /^\/api\/v1\/sessions\/(claude|codex)\/([0-9a-f-]+)(?:\/(timeline|input))?$/i;
-const APPROVAL_PATH_RE = /^\/api\/v1\/sessions\/(claude|codex)\/([0-9a-f-]+)\/approvals\/([A-Za-z0-9_-]+)$/;
-const QUESTION_PATH_RE = /^\/api\/v1\/sessions\/(claude|codex)\/([0-9a-f-]+)\/questions\/([0-9a-f-]+)$/i;
-function json(response, status, value) {
-    const body = JSON.stringify(value);
-    response.writeHead(status, {
-        "content-type": "application/json; charset=utf-8",
-        "content-length": Buffer.byteLength(body),
-        "cache-control": "no-store",
-        "x-content-type-options": "nosniff",
-    });
-    response.end(body);
-}
-function bearer(request) {
-    const value = request.headers.authorization;
-    return value?.startsWith("Bearer ") ? value.slice("Bearer ".length) : null;
-}
-function tokenMatches(expected, actual) {
-    if (actual === null)
-        return false;
-    const left = Buffer.from(expected);
-    const right = Buffer.from(actual);
-    return left.length === right.length && timingSafeEqual(left, right);
-}
-function websocketToken(request) {
-    const auth = bearer(request);
-    if (auth)
-        return auth;
-    const values = String(request.headers["sec-websocket-protocol"] ?? "")
-        .split(",")
-        .map((value) => value.trim());
-    const encoded = values.find((value) => value.startsWith("auth."))?.slice("auth.".length);
-    if (!encoded)
-        return null;
-    try {
-        return Buffer.from(encoded, "base64url").toString("utf8");
-    }
-    catch {
-        return null;
-    }
-}
-function allowedOrigin(request, config) {
-    const origin = request.headers.origin;
-    if (!origin)
-        return true;
-    if (config.allowedOrigins.includes(origin))
-        return true;
-    const host = request.headers.host;
-    if (!host)
-        return false;
-    return origin === `http://${host}` || origin === `https://${host}`;
-}
-async function readJsonBody(request) {
-    const chunks = [];
-    let bytes = 0;
-    for await (const chunk of request) {
-        const value = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-        bytes += value.length;
-        if (bytes > MAX_BODY_BYTES)
-            throw new RangeError("request body too large");
-        chunks.push(value);
-    }
-    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
-}
-function mime(path) {
-    switch (extname(path)) {
-        case ".html": return "text/html; charset=utf-8";
-        case ".js": return "text/javascript; charset=utf-8";
-        case ".css": return "text/css; charset=utf-8";
-        case ".svg": return "image/svg+xml";
-        case ".png": return "image/png";
-        case ".woff2": return "font/woff2";
-        case ".json": return "application/json; charset=utf-8";
-        case ".webmanifest": return "application/manifest+json";
-        default: return "application/octet-stream";
-    }
-}
-async function serveStatic(response, uiDir, pathname) {
-    const relative = pathname === "/" ? "index.html" : pathname.slice(1);
-    const normalized = normalize(relative).replace(/^(\.\.(\/|\\|$))+/, "");
-    let path = join(uiDir, normalized);
-    try {
-        const info = await stat(path);
-        if (!info.isFile())
-            throw new Error("not a file");
-    }
-    catch {
-        path = join(uiDir, "index.html");
-        try {
-            await access(path);
-        }
-        catch {
-            return false;
-        }
-    }
-    const info = await stat(path);
-    const revalidate = path.endsWith("index.html")
-        || path.endsWith("sw.js")
-        || path.endsWith("manifest.webmanifest");
-    response.writeHead(200, {
-        "content-type": mime(path),
-        "content-length": info.size,
-        "cache-control": revalidate ? "no-cache" : "public, max-age=31536000, immutable",
-        "x-content-type-options": "nosniff",
-        "content-security-policy": "default-src 'self'; connect-src 'self' ws: wss:; font-src 'self'; img-src 'self' data:; style-src 'self'; script-src 'self'; base-uri 'none'; frame-ancestors 'none'",
-    });
-    createReadStream(path).pipe(response);
-    return true;
-}
-function websocketSend(socket, value) {
-    if (socket.readyState === WebSocket.OPEN)
-        socket.send(JSON.stringify(value));
-}
-export async function startRemoteGateway(options) {
-    const { config } = options;
-    const gatewayId = options.gatewayId ?? randomUUID();
-    const activeClaudeConnections = new Map();
-    const activeClaudeView = new Map();
-    const pendingApprovals = new Map();
-    const pendingQuestions = new Map();
-    const acceptedInputs = new Map();
-    const clientSockets = new Set();
-    const discovery = options.discovery ?? new RemoteSessionDiscovery({
-        claudeProjectsRoot: options.claudeProjectsRoot ?? join(homedir(), ".claude", "projects"),
-        codexSessionsRoot: options.codexSessionsRoot ?? join(homedir(), ".codex", "sessions"),
-        activeClaude: activeClaudeView,
-    });
-    const broadcast = (event) => {
-        for (const socket of clientSockets)
-            websocketSend(socket, event);
-    };
-    const sessionsChanged = () => broadcast({
-        type: "sessions.changed",
-        protocolVersion: REMOTE_PROTOCOL_VERSION,
-    });
-    const interactionResolved = (sessionId, requestId) => broadcast({
-        type: "interaction.resolved",
-        protocolVersion: REMOTE_PROTOCOL_VERSION,
-        sessionId,
-        requestId,
-    });
-    const listSessions = async () => {
-        const history = await discovery.list();
-        if (!options.codex)
-            return history;
-        let live;
-        try {
-            live = await options.codex.listSessions();
-        }
-        catch {
-            return history;
-        }
-        const merged = new Map(history.map((session) => [`${session.runtime}:${session.id}`, session]));
-        for (const session of live)
-            merged.set(`codex:${session.id}`, session);
-        return [...merged.values()].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)).slice(0, 200);
-    };
-    const unsubscribeCodex = options.codex?.onEvent((event) => {
-        if (event.type === "sessions.changed")
-            sessionsChanged();
-        else
-            broadcast({ ...event, protocolVersion: REMOTE_PROTOCOL_VERSION });
-    });
-    const server = createServer((request, response) => {
-        void (async () => {
-            const url = new URL(request.url ?? "/", `http://${request.headers.host ?? "localhost"}`);
-            if (request.method === "GET" && url.pathname === "/api/v1/health") {
-                json(response, 200, { ok: true, protocolVersion: REMOTE_PROTOCOL_VERSION });
-                return;
-            }
-            if (url.pathname.startsWith("/api/")) {
-                if (!tokenMatches(config.token, bearer(request))) {
-                    json(response, 401, { error: "unauthorized" });
-                    return;
-                }
-                if (!["GET", "HEAD"].includes(request.method ?? "") && !allowedOrigin(request, config)) {
-                    json(response, 403, { error: "origin_not_allowed" });
-                    return;
-                }
-            }
-            if (request.method === "GET" && url.pathname === "/api/v1/sessions") {
-                json(response, 200, { sessions: await listSessions() });
-                return;
-            }
-            if (request.method === "GET" && url.pathname === "/api/v1/identity") {
-                json(response, 200, { gatewayId, pid: process.pid, protocolVersion: REMOTE_PROTOCOL_VERSION });
-                return;
-            }
-            const approvalMatch = APPROVAL_PATH_RE.exec(url.pathname);
-            if (request.method === "POST" && approvalMatch) {
-                const runtime = approvalMatch[1].toLowerCase();
-                const sessionId = approvalMatch[2];
-                const requestId = approvalMatch[3];
-                const body = ResolveRemoteApprovalSchema.parse(await readJsonBody(request));
-                if (runtime === "codex") {
-                    if (!options.codex?.resolveApproval(sessionId, requestId, body.decision)) {
-                        json(response, 409, { error: "approval_not_pending" });
-                        return;
-                    }
-                    interactionResolved(sessionId, requestId);
-                    json(response, 202, { accepted: true });
-                    return;
-                }
-                const pending = pendingApprovals.get(requestId);
-                if (!pending || pending.sessionId !== sessionId) {
-                    json(response, 409, { error: "approval_not_pending" });
-                    return;
-                }
-                const connection = activeClaudeConnections.get(sessionId);
-                if (!connection) {
-                    json(response, 409, { error: "session_not_live" });
-                    return;
-                }
-                websocketSend(connection.socket, GatewayToChannelSchema.parse(pending.bridge ? {
-                    type: "bridge.approval_response",
-                    protocolVersion: REMOTE_PROTOCOL_VERSION,
-                    requestId,
-                    decision: body.decision,
-                } : {
-                    type: "channel.permission_response",
-                    protocolVersion: REMOTE_PROTOCOL_VERSION,
-                    requestId,
-                    decision: body.decision,
-                }));
-                pendingApprovals.delete(requestId);
-                interactionResolved(sessionId, requestId);
-                json(response, 202, { accepted: true });
-                return;
-            }
-            const questionMatch = QUESTION_PATH_RE.exec(url.pathname);
-            if (request.method === "POST" && questionMatch) {
-                const runtime = questionMatch[1].toLowerCase();
-                const sessionId = questionMatch[2];
-                const requestId = questionMatch[3];
-                const body = ResolveRemoteQuestionSchema.parse(await readJsonBody(request));
-                if (runtime === "codex") {
-                    if (!options.codex?.resolveQuestion(sessionId, requestId, body)) {
-                        json(response, 409, { error: "question_not_pending" });
-                        return;
-                    }
-                    interactionResolved(sessionId, requestId);
-                    json(response, 202, { accepted: true });
-                    return;
-                }
-                const pending = pendingQuestions.get(requestId);
-                const connection = activeClaudeConnections.get(sessionId);
-                if (!pending || pending.sessionId !== sessionId || !connection) {
-                    json(response, 409, { error: "question_not_pending" });
-                    return;
-                }
-                websocketSend(connection.socket, GatewayToChannelSchema.parse({
-                    type: "bridge.question_response",
-                    protocolVersion: REMOTE_PROTOCOL_VERSION,
-                    requestId,
-                    answers: body.answers,
-                }));
-                pendingQuestions.delete(requestId);
-                interactionResolved(sessionId, requestId);
-                json(response, 202, { accepted: true });
-                return;
-            }
-            const match = SESSION_PATH_RE.exec(url.pathname);
-            if (request.method === "GET" && match?.[3] === "timeline") {
-                const runtime = match[1].toLowerCase();
-                const discovered = runtime === "codex" && options.codex
-                    ? await options.codex.timeline(match[2])
-                    : await discovery.timeline(runtime, match[2]);
-                if (discovered === null) {
-                    json(response, 404, { error: "session_not_found" });
-                    return;
-                }
-                const items = runtime === "claude"
-                    ? [
-                        ...discovered,
-                        ...[...pendingApprovals.values()].filter((pending) => pending.sessionId === match[2]).map((pending) => pending.item),
-                        ...[...pendingQuestions.values()].filter((pending) => pending.sessionId === match[2]).map((pending) => pending.item),
-                    ]
-                    : discovered;
-                json(response, 200, { items });
-                return;
-            }
-            if (request.method === "POST" && match?.[3] === "input") {
-                const runtime = match[1].toLowerCase();
-                const sessionId = match[2];
-                if (runtime !== "claude" && !options.codex) {
-                    json(response, 501, { error: "runtime_not_connected" });
-                    return;
-                }
-                const input = SubmitRemoteInputSchema.parse(await readJsonBody(request));
-                const prior = acceptedInputs.get(input.idempotencyKey);
-                if (prior) {
-                    json(response, 202, { accepted: true, requestId: prior.requestId, duplicate: true });
-                    return;
-                }
-                const connection = runtime === "claude" ? activeClaudeConnections.get(sessionId) : undefined;
-                if (runtime === "claude" && !connection) {
-                    json(response, 409, { error: "session_not_live" });
-                    return;
-                }
-                const accepted = {
-                    requestId: input.idempotencyKey,
-                    sessionId,
-                    acceptedAt: new Date().toISOString(),
-                };
-                if (runtime === "claude") {
-                    websocketSend(connection.socket, GatewayToChannelSchema.parse({
-                        type: "channel.prompt",
-                        protocolVersion: REMOTE_PROTOCOL_VERSION,
-                        requestId: accepted.requestId,
-                        text: input.text,
-                    }));
-                }
-                else {
-                    await options.codex.submit(sessionId, input);
-                }
-                acceptedInputs.set(input.idempotencyKey, accepted);
-                while (acceptedInputs.size > MAX_DEDUP_ENTRIES) {
-                    const oldest = acceptedInputs.keys().next().value;
-                    if (!oldest)
-                        break;
-                    acceptedInputs.delete(oldest);
-                }
-                const item = {
-                    id: `remote-user:${accepted.requestId}`,
-                    kind: "message",
-                    role: "user",
-                    text: input.text,
-                    createdAt: accepted.acceptedAt,
-                };
-                broadcast({
-                    type: "timeline.appended",
-                    protocolVersion: REMOTE_PROTOCOL_VERSION,
-                    sessionId,
-                    item,
-                });
-                json(response, 202, { accepted: true, requestId: accepted.requestId, duplicate: false });
-                return;
-            }
-            if (url.pathname.startsWith("/api/")) {
-                json(response, 404, { error: "not_found" });
-                return;
-            }
-            if (request.method === "GET" && options.uiDir && await serveStatic(response, options.uiDir, url.pathname))
-                return;
-            json(response, 404, { error: "not_found" });
-        })().catch((error) => {
-            if (response.headersSent) {
-                response.destroy(error instanceof Error ? error : new Error(String(error)));
-                return;
-            }
-            const message = error instanceof SyntaxError ? "invalid_json"
-                : error instanceof RangeError ? "request_too_large"
-                    : "invalid_request";
-            json(response, message === "request_too_large" ? 413 : 400, { error: message });
-        });
-    });
-    const selectProtocol = (protocols) => protocols.has(WS_PROTOCOL) ? WS_PROTOCOL : false;
-    const clientWss = new WebSocketServer({
-        noServer: true,
-        maxPayload: MAX_BODY_BYTES,
-        handleProtocols: selectProtocol,
-    });
-    const channelWss = new WebSocketServer({
-        noServer: true,
-        maxPayload: MAX_BODY_BYTES,
-        handleProtocols: selectProtocol,
-    });
-    server.on("upgrade", (request, socket, head) => {
-        const url = new URL(request.url ?? "/", `http://${request.headers.host ?? "localhost"}`);
-        if (!tokenMatches(config.token, websocketToken(request)) || !allowedOrigin(request, config)) {
-            socket.write("HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n");
-            socket.destroy();
-            return;
-        }
-        const wss = url.pathname === "/ws/client" ? clientWss
-            : url.pathname === "/ws/channel" ? channelWss
-                : null;
-        if (!wss) {
-            socket.write("HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n");
-            socket.destroy();
-            return;
-        }
-        wss.handleUpgrade(request, socket, head, (ws) => {
-            wss.emit("connection", ws, request);
-        });
-    });
-    clientWss.on("connection", (socket) => {
-        clientSockets.add(socket);
-        socket.on("close", () => clientSockets.delete(socket));
-    });
-    channelWss.on("connection", (socket) => {
-        let registration = null;
-        socket.on("message", (raw) => {
-            let decoded;
-            try {
-                decoded = JSON.parse(raw.toString());
-            }
-            catch {
-                socket.close(1008, "invalid JSON");
-                return;
-            }
-            const parsed = ChannelToGatewaySchema.safeParse(decoded);
-            if (!parsed.success) {
-                socket.close(1008, "invalid channel frame");
-                return;
-            }
-            const frame = parsed.data;
-            if (frame.type === "channel.register") {
-                const previous = activeClaudeConnections.get(frame.sessionId);
-                if (previous && previous.socket !== socket)
-                    previous.socket.close(4001, "superseded");
-                registration = { sessionId: frame.sessionId, generation: frame.generation };
-                const active = {
-                    socket,
-                    generation: frame.generation,
-                    pid: frame.pid,
-                    cwd: frame.cwd,
-                    ...(frame.title === undefined ? {} : { title: frame.title }),
-                    busy: false,
-                    updatedAt: new Date().toISOString(),
-                };
-                activeClaudeConnections.set(frame.sessionId, active);
-                activeClaudeView.set(frame.sessionId, {
-                    cwd: active.cwd,
-                    ...(active.title === undefined ? {} : { title: active.title }),
-                    busy: active.busy,
-                    ...(active.updatedAt === undefined ? {} : { updatedAt: active.updatedAt }),
-                });
-                sessionsChanged();
-                return;
-            }
-            if (!registration || registration.sessionId !== frame.sessionId) {
-                socket.close(1008, "register first");
-                return;
-            }
-            if (frame.type === "channel.reply") {
-                const item = {
-                    id: `channel-reply:${frame.requestId}`,
-                    kind: "message",
-                    role: "assistant",
-                    text: frame.text,
-                    createdAt: new Date().toISOString(),
-                };
-                broadcast({
-                    type: "timeline.appended",
-                    protocolVersion: REMOTE_PROTOCOL_VERSION,
-                    sessionId: frame.sessionId,
-                    item,
-                });
-                return;
-            }
-            if (frame.type === "bridge.status") {
-                const current = activeClaudeConnections.get(frame.sessionId);
-                if (!current)
-                    return;
-                const updated = { ...current, busy: frame.busy };
-                activeClaudeConnections.set(frame.sessionId, updated);
-                activeClaudeView.set(frame.sessionId, {
-                    cwd: updated.cwd,
-                    ...(updated.title === undefined ? {} : { title: updated.title }),
-                    busy: updated.busy,
-                    ...(updated.updatedAt === undefined ? {} : { updatedAt: updated.updatedAt }),
-                });
-                sessionsChanged();
-                return;
-            }
-            if (frame.type === "bridge.resolved") {
-                pendingApprovals.delete(frame.requestId);
-                pendingQuestions.delete(frame.requestId);
-                interactionResolved(frame.sessionId, frame.requestId);
-                return;
-            }
-            if (frame.type === "bridge.question") {
-                const item = {
-                    id: `claude-question:${frame.requestId}`,
-                    kind: "question",
-                    requestId: frame.requestId,
-                    questions: frame.questions,
-                    createdAt: new Date().toISOString(),
-                };
-                pendingQuestions.set(frame.requestId, { sessionId: frame.sessionId, item });
-                broadcast({
-                    type: "timeline.appended",
-                    protocolVersion: REMOTE_PROTOCOL_VERSION,
-                    sessionId: frame.sessionId,
-                    item,
-                });
-                return;
-            }
-            const item = {
-                id: `claude-approval:${frame.requestId}`,
-                kind: "approval",
-                requestId: frame.requestId,
-                tool: frame.tool,
-                preview: frame.preview || ("description" in frame ? frame.description : frame.tool),
-                createdAt: new Date().toISOString(),
-            };
-            pendingApprovals.set(frame.requestId, {
-                sessionId: frame.sessionId,
-                item,
-                bridge: frame.type === "bridge.approval",
-            });
-            broadcast({
-                type: "timeline.appended",
-                protocolVersion: REMOTE_PROTOCOL_VERSION,
-                sessionId: frame.sessionId,
-                item,
-            });
-        });
-        socket.on("close", () => {
-            if (!registration)
-                return;
-            const current = activeClaudeConnections.get(registration.sessionId);
-            if (current?.generation !== registration.generation || current.socket !== socket)
-                return;
-            activeClaudeConnections.delete(registration.sessionId);
-            activeClaudeView.delete(registration.sessionId);
-            for (const [requestId, pending] of pendingApprovals) {
-                if (pending.sessionId === registration.sessionId)
-                    pendingApprovals.delete(requestId);
-            }
-            for (const [requestId, pending] of pendingQuestions) {
-                if (pending.sessionId === registration.sessionId)
-                    pendingQuestions.delete(requestId);
-            }
-            sessionsChanged();
-        });
-    });
-    await new Promise((resolve, reject) => {
-        server.once("error", reject);
-        server.listen(options.listenPort ?? config.port, config.host, () => {
-            server.off("error", reject);
-            resolve();
-        });
-    });
-    const address = server.address();
-    if (!address || typeof address === "string")
-        throw new Error("remote gateway did not bind a TCP address");
-    return {
-        host: config.host,
-        port: address.port,
-        gatewayId,
-        activeClaude: activeClaudeView,
-        async close() {
-            unsubscribeCodex?.();
-            for (const socket of [...clientSockets, ...activeClaudeConnections.values()].map((value) => value instanceof WebSocket ? value : value.socket)) {
-                socket.close(1001, "gateway stopping");
-            }
-            await Promise.all([
-                new Promise((resolve) => clientWss.close(() => resolve())),
-                new Promise((resolve) => channelWss.close(() => resolve())),
-                new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve())),
-            ]);
-        },
-    };
-}
-export function encodeWebSocketToken(token) {
-    return `auth.${Buffer.from(token, "utf8").toString("base64url")}`;
-}
-export const REMOTE_WEBSOCKET_PROTOCOL = WS_PROTOCOL;