@zhanguym/chatroom 1.1.0 → 1.2.0-beta.1

package/dist/plugins/web/http/rtc-api-router.js

@@ -0,0 +1,316 @@
+import { randomUUID } from "node:crypto";
+import http from "node:http";
+import { Router } from "express";
+import { z } from "zod";
+import { CreditSender, INITIAL_CREDIT, creditFrame, decodeFrame, metaFrame, parseMeta, readCredit, } from "#plugins/cloud/v2/stream";
+const offerSchema = z
+    .object({
+    type: z.literal("offer"),
+    sdp: z.string().min(1).max(64_000),
+})
+    .strict();
+const openSchema = z
+    .object({
+    method: z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]),
+    path: z.string().max(8192),
+    headers: z.record(z.string(), z.string()).default({}),
+})
+    .strict();
+const STUN = ["stun:stun.cloudflare.com:3478", "stun:stun.l.google.com:19302"];
+const MAX_PEERS = 8;
+const MAX_STREAMS = 32;
+const MAX_UPLOAD = 8 * 1024 * 1024;
+const MAX_IDLE_MS = 30 * 60 * 1000;
+const HEADER_NAMES = new Set([
+    "accept",
+    "content-type",
+    "range",
+    "if-none-match",
+    "if-modified-since",
+    "x-chatroom-mime-type",
+]);
+const RESPONSE_HEADERS = new Set([
+    "content-type",
+    "content-disposition",
+    "content-length",
+    "content-range",
+    "accept-ranges",
+    "cache-control",
+    "etag",
+    "last-modified",
+]);
+/** V2 DataChannel HTTP transport. Cloud and self-hosting use the same HTTPS signaling API. */
+export function createRtcApiRouter(config) {
+    const router = Router();
+    const peers = new Map();
+    router.post("/rtc/offer", async (req, res) => {
+        const parsed = offerSchema.safeParse(req.body);
+        if (!parsed.success ||
+            !parsed.data.sdp.includes("m=application ") ||
+            !parsed.data.sdp.includes("a=fingerprint:") ||
+            !parsed.data.sdp.includes("a=ice-ufrag:")) {
+            res.status(400).json({ error: "invalid_offer" });
+            return;
+        }
+        if (peers.size >= MAX_PEERS) {
+            res.status(429).json({ error: "rtc_capacity" });
+            return;
+        }
+        let library;
+        try {
+            library = await import("node-datachannel");
+        }
+        catch {
+            res.status(503).json({ error: "rtc_unavailable" });
+            return;
+        }
+        const id = randomUUID();
+        const pc = new library.PeerConnection(id, { iceServers: STUN });
+        peers.set(id, pc);
+        const streams = new Map();
+        let dc = null;
+        let closed = false;
+        const cookie = req.headers.cookie ?? "";
+        const host = req.headers.host ?? "localhost";
+        const origin = req.headers.origin ?? "";
+        const cleanup = () => {
+            if (closed)
+                return;
+            closed = true;
+            clearTimeout(expiry);
+            for (const stream of streams.values()) {
+                stream.sender?.cancel();
+                stream.request.destroy();
+            }
+            streams.clear();
+            peers.delete(id);
+            try {
+                dc?.close();
+            }
+            catch {
+                /* connection already closed */
+            }
+            pc.close();
+        };
+        let expiry;
+        const activity = () => {
+            clearTimeout(expiry);
+            expiry = setTimeout(cleanup, MAX_IDLE_MS);
+            expiry.unref();
+        };
+        activity();
+        pc.onStateChange((state) => {
+            if (state === "closed" || state === "failed")
+                cleanup();
+        });
+        pc.onDataChannel((channel) => {
+            if (closed || dc || channel.getLabel() !== "chatroom-v2") {
+                channel.close();
+                return;
+            }
+            dc = channel;
+            channel.setBufferedAmountLowThreshold(512 * 1024);
+            channel.onBufferedAmountLow(() => {
+                for (const stream of streams.values())
+                    stream.sender?.writable();
+            });
+            const send = (frame) => {
+                try {
+                    if (!channel.isOpen() ||
+                        channel.bufferedAmount() > 4 * 1024 * 1024 ||
+                        !channel.sendMessageBinary(Buffer.from(frame))) {
+                        cleanup();
+                        return;
+                    }
+                    activity();
+                }
+                catch {
+                    cleanup();
+                }
+            };
+            const abort = (streamId) => {
+                const stream = streams.get(streamId);
+                if (!stream)
+                    return;
+                streams.delete(streamId);
+                stream.sender?.cancel();
+                stream.request.destroy();
+            };
+            const reset = (streamId, reason) => {
+                if (!streams.has(streamId))
+                    return;
+                abort(streamId);
+                send(metaFrame(5 /* Op.RESET */, streamId, { reason }));
+            };
+            channel.onMessage((raw) => {
+                if (closed || typeof raw === "string") {
+                    cleanup();
+                    return;
+                }
+                try {
+                    activity();
+                    const frame = decodeFrame(new Uint8Array(raw));
+                    if (!frame.id)
+                        throw Error("Reserved RTC control stream");
+                    if (frame.op === 1 /* Op.OPEN */) {
+                        if (streams.has(frame.id) || streams.size >= MAX_STREAMS) {
+                            reset(frame.id, "capacity");
+                            return;
+                        }
+                        const open = openSchema.parse(parseMeta(frame.payload));
+                        if (!(open.path.startsWith("/api/") ||
+                            open.path.startsWith("/assets/")) ||
+                            open.path.startsWith("/api/rtc/") ||
+                            (open.path.startsWith("/assets/") && open.method !== "GET") ||
+                            open.path.includes("#")) {
+                            reset(frame.id, "invalid_path");
+                            return;
+                        }
+                        const headers = { host, cookie };
+                        if (origin)
+                            headers.origin = origin;
+                        for (const [name, value] of Object.entries(open.headers))
+                            if (HEADER_NAMES.has(name.toLowerCase()))
+                                headers[name.toLowerCase()] = value;
+                        const request = http.request({
+                            host: ["0.0.0.0", "::"].includes(config.server.host)
+                                ? "127.0.0.1"
+                                : config.server.host,
+                            port: config.server.port,
+                            method: open.method,
+                            path: open.path,
+                            headers,
+                        }, (response) => {
+                            const stream = streams.get(frame.id);
+                            if (!stream) {
+                                response.destroy();
+                                return;
+                            }
+                            const responseHeaders = Object.fromEntries(Object.entries(response.headers).filter(([name, value]) => RESPONSE_HEADERS.has(name) && typeof value === "string"));
+                            send(metaFrame(2 /* Op.META */, frame.id, {
+                                status: response.statusCode ?? 502,
+                                headers: responseHeaders,
+                            }));
+                            const writer = new CreditSender(frame.id, send, () => response.pause(), () => response.resume(), () => {
+                                streams.delete(frame.id);
+                            }, () => channel.bufferedAmount() < 1024 * 1024);
+                            stream.sender = writer;
+                            response.on("data", (chunk) => {
+                                if (!streams.has(frame.id))
+                                    return;
+                                try {
+                                    writer.enqueue(chunk);
+                                }
+                                catch {
+                                    reset(frame.id, "send_overflow");
+                                    response.destroy();
+                                }
+                            });
+                            response.on("end", () => writer.end());
+                            response.on("error", () => reset(frame.id, "response_error"));
+                            response.on("close", () => {
+                                if (!response.complete && streams.has(frame.id))
+                                    reset(frame.id, "response_disconnected");
+                            });
+                        });
+                        const stream = {
+                            request,
+                            sender: null,
+                            requestBytes: 0,
+                            receiveCredit: INITIAL_CREDIT,
+                            consumed: 0,
+                            drainArmed: false,
+                            ended: false,
+                        };
+                        streams.set(frame.id, stream);
+                        request.on("error", () => {
+                            if (streams.has(frame.id))
+                                reset(frame.id, "request_failed");
+                        });
+                    }
+                    else if (frame.op === 3 /* Op.DATA */) {
+                        const stream = streams.get(frame.id);
+                        if (!stream)
+                            return;
+                        stream.requestBytes += frame.payload.byteLength;
+                        stream.receiveCredit -= frame.payload.byteLength;
+                        if (stream.ended ||
+                            stream.requestBytes > MAX_UPLOAD ||
+                            stream.receiveCredit < 0) {
+                            reset(frame.id, "request_limit");
+                            return;
+                        }
+                        if (stream.request.write(frame.payload)) {
+                            stream.receiveCredit += frame.payload.byteLength;
+                            send(creditFrame(frame.id, frame.payload.byteLength));
+                        }
+                        else {
+                            stream.consumed += frame.payload.byteLength;
+                            if (!stream.drainArmed) {
+                                stream.drainArmed = true;
+                                stream.request.once("drain", () => {
+                                    stream.drainArmed = false;
+                                    if (!streams.has(frame.id))
+                                        return;
+                                    stream.receiveCredit += stream.consumed;
+                                    send(creditFrame(frame.id, stream.consumed));
+                                    stream.consumed = 0;
+                                });
+                            }
+                        }
+                    }
+                    else if (frame.op === 4 /* Op.FIN */) {
+                        const stream = streams.get(frame.id);
+                        if (!stream || stream.ended)
+                            return;
+                        stream.ended = true;
+                        stream.request.end();
+                    }
+                    else if (frame.op === 6 /* Op.CREDIT */) {
+                        streams.get(frame.id)?.sender?.addCredit(readCredit(frame.payload));
+                    }
+                    else if (frame.op === 5 /* Op.RESET */) {
+                        abort(frame.id);
+                    }
+                    else
+                        throw Error("Unexpected RTC frame");
+                }
+                catch {
+                    cleanup();
+                }
+            });
+            channel.onClosed(cleanup);
+            channel.onError(cleanup);
+        });
+        try {
+            const answer = await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => reject(Error("RTC answer timeout")), 12_000);
+                const finish = () => {
+                    const description = pc.localDescription();
+                    if (!description || description.type !== "answer")
+                        return;
+                    clearTimeout(timeout);
+                    resolve({ type: "answer", sdp: description.sdp });
+                };
+                pc.onGatheringStateChange((state) => {
+                    if (state === "complete")
+                        finish();
+                });
+                pc.onLocalDescription(() => {
+                    if (pc.gatheringState() === "complete")
+                        finish();
+                });
+                pc.setRemoteDescription(parsed.data.sdp, "offer");
+            });
+            if (closed)
+                throw Error("RTC negotiation ended");
+            res.json(answer);
+        }
+        catch {
+            cleanup();
+            if (!res.headersSent)
+                res.status(503).json({ error: "rtc_negotiation_failed" });
+        }
+    });
+    return router;
+}

package/dist/plugins/web/http/runtime-api-router.js

@@ -13,7 +13,7 @@ export function createRuntimeApiRouter(application, eventBus, runtimeStatus) {
             throw new ChatRoomError("INVALID_INPUT", "enabled must be a boolean");
         res.json(application.mcpTools.setEnabled(requireString(req.params.toolName, "toolName"), body.enabled));
     });
-    router.get("/events", (req, res) => {
+    router.get("/events", (_req, res) => {
         res.status(200);
         res.setHeader("Content-Type", "text/event-stream");
         res.setHeader("Cache-Control", "no-cache, no-transform");
@@ -25,7 +25,7 @@ export function createRuntimeApiRouter(application, eventBus, runtimeStatus) {
         });
         const keepalive = setInterval(() => res.write(": keepalive\n\n"), 15000);
         keepalive.unref();
-        req.on("close", () => {
+        res.on("close", () => {
             clearInterval(keepalive);
             unsubscribe();
         });

package/dist/plugins/web/http/terminal-api-router.d.ts

@@ -0,0 +1,4 @@
+import { Router } from "express";
+import type { WebRuntime } from "#plugins/web/runtime";
+/** PTY I/O over the existing V2 HTTP stream transport; no extra socket/protocol. */
+export declare function createTerminalApiRouter(app: WebRuntime): Router;

package/dist/plugins/web/http/terminal-api-router.js

@@ -0,0 +1,132 @@
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { Router } from "express";
+import { ChatRoomError } from "#core/errors/chatroom-error";
+import { asyncRoute, bodyRecord, requireString, } from "#presentation/http/http-utils";
+import { defaultTerminalShell, defaultTerminalArgs, } from "#plugins/process/infrastructure/terminal-shell";
+const MAX_RUNNING = 8;
+const MAX_SESSIONS = 24;
+const MAX_INPUT_BYTES = 16 * 1024;
+const MAX_BACKLOG = 512 * 1024;
+const validSize = (n) => Number.isInteger(n) && n >= 2 && n <= 500;
+/** PTY I/O over the existing V2 HTTP stream transport; no extra socket/protocol. */
+export function createTerminalApiRouter(app) {
+    const router = Router();
+    const sessions = new Map();
+    const describe = (s) => ({
+        ...s,
+        state: app.processes.read(s.processId).state,
+    });
+    function requireSession(id) {
+        const session = sessions.get(id);
+        if (!session)
+            throw new ChatRoomError("NOT_FOUND", "Terminal not found");
+        return session;
+    }
+    router.get("/terminal/sessions", (_req, res) => {
+        res.json([...sessions.values()].reverse().map(describe));
+    });
+    router.post("/terminal/sessions", asyncRoute(async (req, res) => {
+        const body = bodyRecord(req.body);
+        const cols = body.cols ?? 80;
+        const rows = body.rows ?? 24;
+        if (!validSize(cols) || !validSize(rows))
+            throw new ChatRoomError("INVALID_INPUT", "Invalid terminal dimensions");
+        const running = [...sessions.values()].filter((s) => app.processes.read(s.processId).state === "running").length;
+        if (running >= MAX_RUNNING || sessions.size >= MAX_SESSIONS)
+            throw new ChatRoomError("CONFLICT", "Too many terminal sessions");
+        const shell = defaultTerminalShell();
+        const snapshot = await app.processes.start({
+            command: shell,
+            args: defaultTerminalArgs(),
+            cwd: homedir(),
+            pty: true,
+            cols,
+            rows,
+            env: {
+                ...process.env,
+                TERM: "xterm-256color",
+                COLORTERM: "truecolor",
+            },
+            timeoutMs: 0,
+        }, { source: "gui", action: "start" });
+        const session = {
+            id: randomUUID(),
+            processId: snapshot.processId,
+            shell,
+            createdAt: snapshot.startedAt,
+        };
+        sessions.set(session.id, session);
+        res.status(201).json(describe(session));
+    }));
+    router.post("/terminal/sessions/:id/input", (req, res) => {
+        const session = requireSession(requireString(req.params.id, "id"));
+        const body = bodyRecord(req.body);
+        const data = requireString(body.data, "data");
+        if (Buffer.byteLength(data, "utf8") > MAX_INPUT_BYTES)
+            throw new ChatRoomError("INVALID_INPUT", "Terminal input too large");
+        app.processes.write(session.processId, data);
+        res.status(204).end();
+    });
+    router.post("/terminal/sessions/:id/resize", (req, res) => {
+        const session = requireSession(requireString(req.params.id, "id"));
+        const body = bodyRecord(req.body);
+        if (!validSize(body.cols) || !validSize(body.rows))
+            throw new ChatRoomError("INVALID_INPUT", "Invalid terminal dimensions");
+        app.processes.resize(session.processId, body.cols, body.rows);
+        res.status(204).end();
+    });
+    router.delete("/terminal/sessions/:id", asyncRoute(async (req, res) => {
+        const session = requireSession(requireString(req.params.id, "id"));
+        if (app.processes.read(session.processId).state === "running")
+            await app.processKill(session.processId, false);
+        sessions.delete(session.id);
+        res.status(204).end();
+    }));
+    router.get("/terminal/sessions/:id/stream", (req, res) => {
+        const session = requireSession(requireString(req.params.id, "id"));
+        res.status(200);
+        res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
+        res.setHeader("Cache-Control", "private, no-store, no-transform");
+        res.setHeader("X-Accel-Buffering", "no");
+        res.flushHeaders();
+        let finished = false;
+        const write = (type, payload) => {
+            if (finished || res.destroyed)
+                return;
+            if (res.writableLength > MAX_BACKLOG) {
+                res.destroy(new Error("Terminal stream is too slow"));
+                return;
+            }
+            res.write("event: " + type + "\n" + "data: " + JSON.stringify(payload) + "\n\n");
+        };
+        // Attach before taking snapshot: no output gap between backlog and live bytes.
+        const { snapshot, unsubscribe } = app.processes.subscribeOutput(session.processId, (chunk) => {
+            if (!chunk) {
+                write("exit", describe(session));
+                res.end();
+                return;
+            }
+            for (let offset = 0; offset < chunk.length; offset += 16 * 1024)
+                write("output", chunk.subarray(offset, offset + 16 * 1024).toString("base64"));
+        });
+        write("snapshot", {
+            output: Buffer.from(snapshot.stdout, "utf8").toString("base64"),
+            state: snapshot.state,
+        });
+        if (snapshot.state !== "running") {
+            write("exit", describe(session));
+            unsubscribe();
+            res.end();
+            return;
+        }
+        const heartbeat = setInterval(() => write("ping", null), 15000);
+        heartbeat.unref();
+        res.on("close", () => {
+            finished = true;
+            clearInterval(heartbeat);
+            unsubscribe();
+        });
+    });
+    return router;
+}

package/dist/plugins/web/plugin.js

@@ -11,7 +11,7 @@ export function createWebPlugin() {
         id: "web",
         activate(context) {
             context.services.provide(WebServiceToken, {
-                application: new WebRuntime(context.services.require(WorkspaceServiceToken), context.services.require(GitAccessToken), context.operations, context.services.require(ProcessServiceToken), context.services.require(ComputerServiceToken), context.services.require(AgentServiceToken), context.mcpTools),
+                application: new WebRuntime(context.services.require(WorkspaceServiceToken), context.services.require(GitAccessToken), context.operations, context.services.require(ProcessServiceToken), context.services.require(ComputerServiceToken), context.services.require(AgentServiceToken), context.mcpTools, context.customMcp),
             });
         },
     };

package/dist/plugins/web/runtime.d.ts

@@ -4,6 +4,7 @@ import type { GitAccess } from "#app/git-access";
 import type { ProcessSupervisor } from "#plugins/process/process-supervisor";
 import type { WorkspaceService } from "#plugins/workspace/workspace-service";
 import type { AgentRuntime } from "#plugins/agent/runtime";
+import type { CustomMcpManager } from "#mcp/custom/manager";
 import type { McpToolControl } from "#mcp/server/tool-control";
 export declare class WebRuntime {
     readonly workspaces: WorkspaceService;
@@ -13,7 +14,8 @@ export declare class WebRuntime {
     readonly computer: ComputerService;
     readonly agents: AgentRuntime;
     readonly mcpTools: McpToolControl;
-    constructor(workspaces: WorkspaceService, git: GitAccess, operations: OperationLog, processes: ProcessSupervisor, computer: ComputerService, agents: AgentRuntime, mcpTools: McpToolControl);
+    readonly customMcp: CustomMcpManager;
+    constructor(workspaces: WorkspaceService, git: GitAccess, operations: OperationLog, processes: ProcessSupervisor, computer: ComputerService, agents: AgentRuntime, mcpTools: McpToolControl, customMcp: CustomMcpManager);
     processKill(processId: string, force?: boolean): Promise<import("./api-types.js").ProcessSnapshot>;
     listProcesses(): import("./api-types.js").ProcessSummary[];
     getProcess(processId: string): import("./api-types.js").ProcessSnapshot;

package/dist/plugins/web/runtime.js

@@ -6,7 +6,8 @@ export class WebRuntime {
     computer;
     agents;
     mcpTools;
-    constructor(workspaces, git, operations, processes, computer, agents, mcpTools) {
+    customMcp;
+    constructor(workspaces, git, operations, processes, computer, agents, mcpTools, customMcp) {
         this.workspaces = workspaces;
         this.git = git;
         this.operations = operations;
@@ -14,6 +15,7 @@ export class WebRuntime {
         this.computer = computer;
         this.agents = agents;
         this.mcpTools = mcpTools;
+        this.customMcp = customMcp;
     }
     processKill(processId, force = false) {
         return this.operations.run({