@zhanguym/chatroom 1.2.0-beta.0 → 1.2.0-beta.1

package/dist/mcp/server/create-mcp-server.d.ts

@@ -1,3 +1,4 @@
 import { type McpHttpHandler } from "@modelcontextprotocol/server";
+import type { CustomMcpManager } from "#mcp/custom/manager";
 import type { PluginManager } from "#plugins/plugin-manager";
-export declare function createChatRoomMcpHandler(plugins: PluginManager): McpHttpHandler;
+export declare function createChatRoomMcpHandler(plugins: PluginManager, custom: CustomMcpManager): McpHttpHandler;

package/dist/mcp/server/create-mcp-server.js

@@ -1,16 +1,17 @@
 import { createMcpHandler, McpServer, } from "@modelcontextprotocol/server";
 import { CHATROOM_NAME, CHATROOM_VERSION } from "#core/runtime/identity";
-export function createChatRoomMcpHandler(plugins) {
-    return createMcpHandler(() => createServer(plugins), {
+export function createChatRoomMcpHandler(plugins, custom) {
+    return createMcpHandler(() => createServer(plugins, custom), {
         legacy: "stateless",
         responseMode: "auto",
     });
 }
-function createServer(plugins) {
+function createServer(plugins, custom) {
     const server = new McpServer({
         name: CHATROOM_NAME,
         version: CHATROOM_VERSION,
     });
     plugins.registerMcp(server);
+    custom.registerMcp(server);
     return server;
 }

package/dist/mcp/server/tool-control.d.ts

@@ -1,6 +1,7 @@
 import type { RegisteredTool } from "@modelcontextprotocol/server";
 export interface McpToolSettingStore {
     disabledTools(): string[];
+    configuredTools?(): string[];
     setEnabled(name: string, enabled: boolean): void;
 }
 export interface McpToolSummary {
@@ -15,14 +16,18 @@ interface McpToolDefinition {
     pluginId: string;
     title: string;
     description: string;
+    defaultEnabled?: boolean;
 }
 export declare class McpToolControl {
     private readonly store;
     private readonly disabled;
+    private readonly configured;
     private readonly definitions;
     private readonly handles;
     constructor(store: McpToolSettingStore);
     define(definition: McpToolDefinition): void;
+    undefine(name: string): void;
+    isEnabled(name: string): boolean;
     attach(name: string, tool: RegisteredTool): void;
     list(): McpToolSummary[];
     setEnabled(name: string, enabled: boolean): McpToolSummary;

package/dist/mcp/server/tool-control.js

@@ -2,18 +2,34 @@ import { ChatRoomError } from "#core/errors/chatroom-error";
 export class McpToolControl {
     store;
     disabled = new Set();
+    configured = new Set();
     definitions = new Map();
     handles = new Map();
     constructor(store) {
         this.store = store;
         for (const name of store.disabledTools())
             this.disabled.add(name);
+        for (const name of store.configuredTools?.() ?? [])
+            this.configured.add(name);
     }
     define(definition) {
         const existing = this.definitions.get(definition.name);
         if (existing && existing.pluginId !== definition.pluginId)
             throw new Error(`MCP tool already belongs to another plugin: ${definition.name}`);
         this.definitions.set(definition.name, definition);
+        if (definition.defaultEnabled === false &&
+            !this.configured.has(definition.name))
+            this.setEnabled(definition.name, false);
+    }
+    undefine(name) {
+        this.definitions.delete(name);
+        for (const reference of this.handles.get(name) ?? []) {
+            reference.deref()?.remove();
+        }
+        this.handles.delete(name);
+    }
+    isEnabled(name) {
+        return this.definitions.has(name) && !this.disabled.has(name);
     }
     attach(name, tool) {
         let tools = this.handles.get(name);
@@ -46,6 +62,7 @@ export class McpToolControl {
         if (enabled === !this.disabled.has(name))
             return { ...definition, enabled };
         this.store.setEnabled(name, enabled);
+        this.configured.add(name);
         if (enabled)
             this.disabled.delete(name);
         else

package/dist/plugins/computer/computer-schemas.d.ts

@@ -72,6 +72,10 @@ export declare const computerSnapshotSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const computerSnapshotMetadataSchema: z.ZodObject<{
+    cursor: z.ZodNullable<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
     snapshotId: z.ZodString;
     revision: z.ZodNumber;
     display: z.ZodNullable<z.ZodObject<{
@@ -84,10 +88,6 @@ export declare const computerSnapshotMetadataSchema: z.ZodObject<{
     }, z.core.$strip>>;
     activeApp: z.ZodNullable<z.ZodString>;
     activeWindow: z.ZodNullable<z.ZodString>;
-    cursor: z.ZodNullable<z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-    }, z.core.$strip>>;
     elements: z.ZodArray<z.ZodObject<{
         id: z.ZodNumber;
         role: z.ZodString;
@@ -234,6 +234,10 @@ export declare const computerActionMetadataSchema: z.ZodObject<{
     }>;
     focusChanged: z.ZodBoolean;
     snapshot: z.ZodOptional<z.ZodObject<{
+        cursor: z.ZodNullable<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
         snapshotId: z.ZodString;
         revision: z.ZodNumber;
         display: z.ZodNullable<z.ZodObject<{
@@ -246,10 +250,6 @@ export declare const computerActionMetadataSchema: z.ZodObject<{
         }, z.core.$strip>>;
         activeApp: z.ZodNullable<z.ZodString>;
         activeWindow: z.ZodNullable<z.ZodString>;
-        cursor: z.ZodNullable<z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strip>>;
         elements: z.ZodArray<z.ZodObject<{
             id: z.ZodNumber;
             role: z.ZodString;

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.js

@@ -8,6 +8,7 @@ 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";
@@ -15,10 +16,12 @@ 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({

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/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({