@zhanguym/chatroom 1.1.0 → 1.2.0-beta.1

package/dist/plugins/process/infrastructure/pty-process-backend.js

@@ -12,8 +12,8 @@ export class PtyProcessBackend {
         const env = Object.fromEntries(Object.entries(options.env).filter((entry) => typeof entry[1] === "string"));
         const processHandle = pty.spawn(command, args, {
             name: env.TERM ?? "xterm-256color",
-            cols: 120,
-            rows: 30,
+            cols: options.cols ?? 120,
+            rows: options.rows ?? 30,
             cwd: options.cwd,
             env,
         });
@@ -31,6 +31,9 @@ class PtyBackendProcess {
     write(data) {
         this.processHandle.write(data);
     }
+    resize(cols, rows) {
+        this.processHandle.resize(cols, rows);
+    }
     kill(signal = "SIGTERM") {
         if (process.platform === "win32") {
             this.processHandle.kill();

package/dist/plugins/process/infrastructure/terminal-shell.d.ts

@@ -0,0 +1,4 @@
+/** Select the OS default interactive shell for a local terminal session. */
+export declare function defaultTerminalShell(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): string;
+/** macOS Terminal starts an interactive login shell; match its PATH initialization. */
+export declare function defaultTerminalArgs(platform?: NodeJS.Platform): string[];

package/dist/plugins/process/infrastructure/terminal-shell.js

@@ -0,0 +1,10 @@
+/** Select the OS default interactive shell for a local terminal session. */
+export function defaultTerminalShell(platform = process.platform, env = process.env) {
+    return platform === "win32"
+        ? env.ComSpec || env.COMSPEC || "cmd.exe"
+        : env.SHELL || "/bin/sh";
+}
+/** macOS Terminal starts an interactive login shell; match its PATH initialization. */
+export function defaultTerminalArgs(platform = process.platform) {
+    return platform === "darwin" ? ["-l"] : [];
+}

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/types.d.ts

@@ -3,6 +3,7 @@ import type { AppDatabase } from "#infrastructure/database/app-database";
 import type { PluginMcpRegistrar } from "#mcp/server/plugin-mcp-registrar";
 import type { OperationLog } from "#operations/operation-log";
 import type { McpToolControl } from "#mcp/server/tool-control";
+import type { CustomMcpManager } from "#mcp/custom/manager";
 import type { RuntimeEventBus } from "#app/event-bus";
 import type { ExternalAccessRegistry } from "#app/external-access-registry";
 import type { LogWriter } from "#core/logging/types";
@@ -12,6 +13,7 @@ export interface PluginContext {
     database: AppDatabase;
     operations: OperationLog;
     mcpTools: McpToolControl;
+    customMcp: CustomMcpManager;
     events: RuntimeEventBus;
     externalAccess: ExternalAccessRegistry;
     services: ServiceRegistry;

package/dist/plugins/web/api-types.d.ts

@@ -2,6 +2,7 @@ import type { Operation as DomainOperation } from "#core/operations/types";
 import type { GitBranch, GitChange, GitCommit, GitDiff, GitStatus } from "#app/git-access";
 import type { ProcessSnapshot, ProcessSummary } from "#plugins/process/types";
 import type { AgentAttachment, AgentHistory, AgentHistoryUpdate, AgentInteractionResponse, AgentItem, AgentModel, AgentProviderId, AgentProviderDetails, AgentReviewTarget, AgentProviderStatus, AgentSession, AgentTurn, AgentTurnSource } from "#plugins/agent/types";
+import type { CustomMcpServerSummary } from "#mcp/custom/types";
 import type { McpToolSummary as DomainMcpToolSummary } from "#mcp/server/tool-control";
 import type { CloudServiceId, CloudStatus as DomainCloudStatus } from "#plugins/cloud/types";
 import type { ComputerDisplay, ComputerPermission, ComputerStatus } from "#plugins/computer/types";
@@ -46,6 +47,7 @@ export interface UpdateStatus {
     releaseUrl: string | null;
 }
 export type McpToolSummary = DomainMcpToolSummary;
+export type { CustomMcpServerSummary };
 export type CloudService = CloudServiceId;
 export type CloudStatus = DomainCloudStatus;
 export interface WorkspaceFileContent {

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,20 +2,26 @@ 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";
 import { createComputerApiRouter } from "./computer-api-router.js";
 import { apiAuthentication, createPrivateAuthApiRouter, createPublicAuthApiRouter, } from "./auth-api-router.js";
+import { createCustomMcpApiRouter, createCustomMcpOAuthCallbackRouter, } from "./custom-mcp-api-router.js";
 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(createCustomMcpOAuthCallbackRouter(application.customMcp));
     router.use(apiAuthentication(auth, ingress));
     router.use(createPrivateAuthApiRouter(passkeys, ingress, logs));
+    router.use(createRtcApiRouter(config));
     router.use(createRuntimeApiRouter(application, eventBus, runtimeStatus));
+    router.use(createCustomMcpApiRouter(application.customMcp, ingress));
     router.use(createLogsApiRouter(logs));
     router.get("/operations", (req, res) => {
         res.json(application.operations.list({
@@ -49,6 +55,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/custom-mcp-api-router.d.ts

@@ -0,0 +1,6 @@
+import { Router } from "express";
+import type { IngressPolicy } from "#auth/ingress-policy";
+import type { CustomMcpManager } from "#mcp/custom/manager";
+export declare function createCustomMcpApiRouter(manager: CustomMcpManager, ingress: IngressPolicy): Router;
+/** Public OAuth callback: the random state is single-use and scoped to an initiated login. */
+export declare function createCustomMcpOAuthCallbackRouter(manager: CustomMcpManager): Router;

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

@@ -0,0 +1,114 @@
+import { Router } from "express";
+import { ChatRoomError } from "#core/errors/chatroom-error";
+import { bodyRecord, requireString } from "#presentation/http/http-utils";
+function settings(body, partial = false) {
+    const config = {};
+    const str = (key) => {
+        if (typeof body[key] !== "string")
+            throw new ChatRoomError("INVALID_INPUT", key + " must be a string");
+        return body[key];
+    };
+    if (!partial || "name" in body)
+        config.name = str("name").trim();
+    if (!partial || "type" in body) {
+        const type = str("type");
+        if (type !== "stdio" && type !== "http")
+            throw new ChatRoomError("INVALID_INPUT", "Unsupported MCP transport");
+        config.type = type;
+    }
+    for (const key of ["command", "cwd", "url"])
+        if (key in body)
+            config[key] = str(key);
+    if ("args" in body) {
+        if (!Array.isArray(body.args) ||
+            body.args.some((value) => typeof value !== "string"))
+            throw new ChatRoomError("INVALID_INPUT", "args must be an array of strings");
+        config.args = body.args;
+    }
+    for (const key of ["env", "headers"]) {
+        if (!(key in body))
+            continue;
+        const data = body[key];
+        if (!data ||
+            typeof data !== "object" ||
+            Array.isArray(data) ||
+            Object.entries(data).some(([name, value]) => !name.trim() || typeof value !== "string"))
+            throw new ChatRoomError("INVALID_INPUT", key + " must be a string map");
+        config[key] = data;
+    }
+    if ("authMode" in body) {
+        const value = str("authMode");
+        if (!["auto", "none", "headers"].includes(value))
+            throw new ChatRoomError("INVALID_INPUT", "Unsupported MCP authentication");
+        config.authMode = value;
+    }
+    if (!partial || "enabled" in body) {
+        if (typeof body.enabled !== "boolean")
+            throw new ChatRoomError("INVALID_INPUT", "enabled must be a boolean");
+        config.enabled = body.enabled;
+    }
+    return config;
+}
+export function createCustomMcpApiRouter(manager, ingress) {
+    const router = Router();
+    router.get("/mcp/servers", (_req, res) => res.json(manager.list()));
+    router.post("/mcp/servers", async (req, res) => {
+        const config = settings(bodyRecord(req.body));
+        res.status(201).json(await manager.create(config));
+    });
+    router.post("/mcp/servers/test", async (req, res) => {
+        const config = settings(bodyRecord(req.body));
+        res.json(await manager.test(config));
+    });
+    router.post("/mcp/servers/:id/test", async (req, res) => {
+        res.json(await manager.testStored(requireString(req.params.id, "id")));
+    });
+    router.patch("/mcp/servers/:id", async (req, res) => {
+        const id = requireString(req.params.id, "id");
+        res.json(await manager.update(id, settings(bodyRecord(req.body), true)));
+    });
+    router.delete("/mcp/servers/:id", async (req, res) => {
+        await manager.remove(requireString(req.params.id, "id"));
+        res.json({ ok: true });
+    });
+    router.post("/mcp/servers/:id/authorize", async (req, res) => {
+        const id = requireString(req.params.id, "id");
+        const origin = ingress.expectedWebOrigin(req) ??
+            `http://${req.get("host") ?? "localhost:8765"}`;
+        res.json(await manager.authorize(id, origin + "/api/mcp/oauth/callback"));
+    });
+    router.post("/mcp/servers/:id/revoke", async (req, res) => {
+        await manager.revokeAuthorization(requireString(req.params.id, "id"));
+        res.json({ ok: true });
+    });
+    router.post("/mcp/servers/:id/refresh", async (req, res) => {
+        res.json(await manager.refresh(requireString(req.params.id, "id")));
+    });
+    return router;
+}
+/** Public OAuth callback: the random state is single-use and scoped to an initiated login. */
+export function createCustomMcpOAuthCallbackRouter(manager) {
+    const router = Router();
+    router.get("/mcp/oauth/callback", async (req, res) => {
+        const query = new URLSearchParams();
+        for (const key of ["state", "code", "iss", "error"])
+            if (typeof req.query[key] === "string")
+                query.set(key, req.query[key]);
+        let success = false;
+        try {
+            await manager.completeAuthorization(query);
+            success = true;
+        }
+        catch {
+            // Never expose OAuth codes, provider errors, or credentials in this page.
+        }
+        res.setHeader("Cache-Control", "no-store");
+        res.setHeader("Content-Security-Policy", "default-src 'none'; script-src 'unsafe-inline'; frame-ancestors 'none'");
+        res.status(success ? 200 : 400).type("html")
+            .send(`<!doctype html><html lang="en"><meta charset="utf-8"><title>ChatRoom MCP</title>
+<body><p>${success ? "Authorization completed. You may close this window." : "Authorization failed. Return to ChatRoom and retry."}</p>
+<script>window.opener?.postMessage({type:"chatroom:mcp-oauth-completed",success:${success}},window.location.origin);window.close();</script>
+</body></html>`);
+    });
+    return router;
+}

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;