@zhanguym/chatroom 1.1.0 → 1.2.0-beta.0

package/dist/plugins/process/process-supervisor.d.ts

@@ -27,6 +27,12 @@ export declare class ProcessSupervisor {
     list(): ProcessSnapshot[];
     summaries(): ProcessSummary[];
     write(processId: ProcessId, data: string): ProcessSnapshot;
+    /** Subscribe to raw PTY output; terminal reconnects start from the snapshot. */
+    subscribeOutput(processId: ProcessId, listener: (chunk: Buffer | null, stream?: "stdout" | "stderr") => void): {
+        snapshot: ProcessSnapshot;
+        unsubscribe: () => void;
+    };
+    resize(processId: ProcessId, cols: number, rows: number): void;
     kill(processId: ProcessId, force?: boolean): ProcessSnapshot;
     shutdown(): Promise<void>;
     private onOutput;

package/dist/plugins/process/process-supervisor.js

@@ -36,6 +36,7 @@ export class ProcessSupervisor {
                     args,
                     cwd: request.cwd,
                     pty: request.pty ?? false,
+                    ...(request.pty ? { cols: request.cols, rows: request.rows } : {}),
                     timeoutMs: request.timeoutMs ?? this.defaultTimeoutMs,
                     env: request.env ?? {},
                 },
@@ -47,6 +48,8 @@ export class ProcessSupervisor {
             backend = await (request.pty ? this.backends.pty : this.backends.pipe).start(request.command, args, {
                 cwd: request.cwd,
                 env: childEnvironment(request.env),
+                ...(request.cols !== undefined ? { cols: request.cols } : {}),
+                ...(request.rows !== undefined ? { rows: request.rows } : {}),
             });
         }
         catch (error) {
@@ -81,6 +84,7 @@ export class ProcessSupervisor {
             timeout: null,
             forceTimeout: null,
             outputEventTimer: null,
+            outputListeners: new Set(),
             timedOut: false,
             operationId,
             settled,
@@ -129,6 +133,23 @@ export class ProcessSupervisor {
         item.backend.write(data);
         return this.snapshotOf(processId, item);
     }
+    /** Subscribe to raw PTY output; terminal reconnects start from the snapshot. */
+    subscribeOutput(processId, listener) {
+        const item = this.require(processId);
+        item.outputListeners.add(listener);
+        return {
+            snapshot: this.snapshotOf(processId, item),
+            unsubscribe: () => item.outputListeners.delete(listener),
+        };
+    }
+    resize(processId, cols, rows) {
+        const item = this.requireRunning(processId);
+        if (!item.request.pty || !item.backend.resize)
+            throw new ChatRoomError("UNSUPPORTED", "Not a resizable PTY");
+        if (![cols, rows].every((value) => Number.isInteger(value) && value >= 2 && value <= 500))
+            throw new ChatRoomError("INVALID_INPUT", "Invalid terminal dimensions");
+        item.backend.resize(cols, rows);
+    }
     kill(processId, force = false) {
         const item = this.requireRunning(processId);
         item.backend.kill(force ? "SIGKILL" : "SIGTERM");
@@ -161,6 +182,8 @@ export class ProcessSupervisor {
         if (!item || item.state !== "running")
             return;
         (stream === "stdout" ? item.stdout : item.stderr).append(chunk);
+        for (const listener of item.outputListeners)
+            listener(chunk, stream);
         if (!item.outputEventTimer) {
             item.outputEventTimer = setTimeout(() => {
                 item.outputEventTimer = null;
@@ -183,6 +206,9 @@ export class ProcessSupervisor {
         item.exitCode = exitCode;
         item.signal = signal;
         item.state = signal ? "killed" : exitCode === 0 ? "exited" : "failed";
+        for (const listener of item.outputListeners)
+            listener(null);
+        item.outputListeners.clear();
         const snapshot = this.snapshotOf(processId, item);
         this.operations.finish(item.operationId, exitCode === 0 && !signal ? "success" : signal ? "cancelled" : "error", {
             stdout: snapshot.stdout,

package/dist/plugins/process/types.d.ts

@@ -6,6 +6,8 @@ export interface ProcessStartRequest {
     args?: string[];
     env?: Record<string, string>;
     pty?: boolean;
+    cols?: number;
+    rows?: number;
     timeoutMs?: number;
 }
 export interface ProcessSnapshot {

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

@@ -6,7 +6,8 @@ import type { PasskeyService } from "#auth/passkey-service";
 import type { IngressPolicy } from "#auth/ingress-policy";
 import type { CloudController } from "#plugins/cloud/controller";
 import type { LogService } from "#core/logging/types";
-export declare function createApiRouter(application: WebRuntime, eventBus: RuntimeEventBus, auth: AuthService, passkeys: PasskeyService, ingress: IngressPolicy, cloud: CloudController, logs: LogService, runtimeStatus: () => {
+import type { ChatRoomConfig } from "#config/types";
+export declare function createApiRouter(application: WebRuntime, eventBus: RuntimeEventBus, auth: AuthService, passkeys: PasskeyService, ingress: IngressPolicy, cloud: CloudController, logs: LogService, config: ChatRoomConfig, runtimeStatus: () => {
     version: string;
     mcpRequests: number;
     uptimeMinutes: number;

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

@@ -2,6 +2,7 @@ import { Router } from "express";
 import { ChatRoomError } from "#core/errors/chatroom-error";
 import { boundedIntegerQuery, requireString, } from "#presentation/http/http-utils";
 import { createProcessApiRouter } from "./process-api-router.js";
+import { createTerminalApiRouter } from "./terminal-api-router.js";
 import { createWorkspaceApiRouter } from "./workspace-api-router.js";
 import { createGitApiRouter } from "./git-api-router.js";
 import { createCloudApiRouter } from "./cloud-api-router.js";
@@ -10,11 +11,13 @@ import { apiAuthentication, createPrivateAuthApiRouter, createPublicAuthApiRoute
 import { createRuntimeApiRouter } from "./runtime-api-router.js";
 import { createLogsApiRouter } from "./logs-api-router.js";
 import { createAgentApiRouter } from "./agent-api-router.js";
-export function createApiRouter(application, eventBus, auth, passkeys, ingress, cloud, logs, runtimeStatus) {
+import { createRtcApiRouter } from "./rtc-api-router.js";
+export function createApiRouter(application, eventBus, auth, passkeys, ingress, cloud, logs, config, runtimeStatus) {
     const router = Router();
     router.use(createPublicAuthApiRouter(auth, passkeys, ingress, logs));
     router.use(apiAuthentication(auth, ingress));
     router.use(createPrivateAuthApiRouter(passkeys, ingress, logs));
+    router.use(createRtcApiRouter(config));
     router.use(createRuntimeApiRouter(application, eventBus, runtimeStatus));
     router.use(createLogsApiRouter(logs));
     router.get("/operations", (req, res) => {
@@ -49,6 +52,7 @@ export function createApiRouter(application, eventBus, auth, passkeys, ingress,
     router.use(createWorkspaceApiRouter(application));
     router.use(createGitApiRouter(application));
     router.use(createProcessApiRouter(application));
+    router.use(createTerminalApiRouter(application));
     router.use(createAgentApiRouter(application.agents));
     router.use(createComputerApiRouter(application.computer, application.operations, ingress));
     router.use(createCloudApiRouter(cloud, application.operations));

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

@@ -16,7 +16,7 @@ export function createLogsApiRouter(logs) {
             ...(modules?.length ? { modules: new Set(modules) } : {}),
         }));
     }));
-    router.get("/logs/stream", (req, res) => {
+    router.get("/logs/stream", (_req, res) => {
         res.status(200);
         res.setHeader("Content-Type", "text/event-stream");
         res.setHeader("Cache-Control", "no-cache, no-transform");
@@ -28,7 +28,7 @@ export function createLogsApiRouter(logs) {
         });
         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/process-api-router.js

@@ -6,6 +6,54 @@ export function createProcessApiRouter(application) {
     router.get("/processes/:processId/summary", (req, res) => {
         res.json(application.getProcessSummary(requireString(req.params.processId, "processId")));
     });
+    router.get("/processes/:processId/stream", (req, res) => {
+        const processId = requireString(req.params.processId, "processId");
+        // Validate and attach before flushing headers: invalid IDs return JSON 404.
+        let closed = false;
+        const write = (type, data) => {
+            if (closed || res.destroyed)
+                return;
+            if (res.writableLength > 512 * 1024) {
+                res.destroy(new Error("Process output stream is too slow"));
+                return;
+            }
+            res.write(`event: ${type}\ndata: ${JSON.stringify(data)}\n\n`);
+        };
+        const { snapshot, unsubscribe } = application.processes.subscribeOutput(processId, (chunk, stream) => {
+            if (!chunk) {
+                const { stdout: _stdout, stderr: _stderr, ...status } = application.getProcess(processId);
+                write("exit", status);
+                res.end();
+            }
+            else {
+                for (let offset = 0; offset < chunk.length; offset += 16 * 1024)
+                    write("output", {
+                        stream: stream ?? "stdout",
+                        bytes: chunk
+                            .subarray(offset, offset + 16 * 1024)
+                            .toString("base64"),
+                    });
+            }
+        });
+        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();
+        write("snapshot", snapshot);
+        if (snapshot.state !== "running") {
+            res.end();
+            unsubscribe();
+            return;
+        }
+        const heartbeat = setInterval(() => write("ping", null), 15_000);
+        heartbeat.unref();
+        res.on("close", () => {
+            closed = true;
+            clearInterval(heartbeat);
+            unsubscribe();
+        });
+    });
     router.get("/processes/:processId", (req, res) => {
         res.json(application.getProcess(requireString(req.params.processId, "processId")));
     });

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

@@ -0,0 +1,4 @@
+import { Router } from "express";
+import type { ChatRoomConfig } from "#config/types";
+/** V2 DataChannel HTTP transport. Cloud and self-hosting use the same HTTPS signaling API. */
+export declare function createRtcApiRouter(config: ChatRoomConfig): Router;

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;