@zhanguym/chatroom 1.2.0 → 1.3.3

package/dist/mcp/custom/manager.js

@@ -76,14 +76,16 @@ export class CustomMcpManager {
     repository;
     control;
     operations;
+    operationSource;
     oauth;
     authorizationFlows = new Map();
     entries = new Map();
     closed = false;
-    constructor(repository, control, operations, dataDir) {
+    constructor(repository, control, operations, dataDir, operationSource = "mcp") {
         this.repository = repository;
         this.control = control;
         this.operations = operations;
+        this.operationSource = operationSource;
         this.oauth = dataDir ? new CustomMcpOAuthStore(dataDir) : null;
         for (const config of repository.list())
             this.entries.set(config.id, newEntry(config));
@@ -94,6 +96,7 @@ export class CustomMcpManager {
                 void this.connect(entry);
     }
     list() {
+        this.syncRepository();
         return [...this.entries.values()].map((entry) => ({
             id: entry.config.id,
             name: entry.config.name,
@@ -277,6 +280,7 @@ export class CustomMcpManager {
             (Object.keys(config.headers ?? {}).length ? "headers" : "auto"));
     }
     registerMcp(server) {
+        this.syncRepository();
         for (const entry of this.entries.values()) {
             if (!entry.config.enabled || entry.status !== "connected")
                 continue;
@@ -308,7 +312,7 @@ export class CustomMcpManager {
         const client = entry.client;
         const operation = this.operations.start({
             pluginId: "custom-mcp",
-            source: "mcp",
+            source: this.operationSource,
             action: entry.config.name + "/" + name,
             input: { serverId: id, toolName: name },
         });
@@ -475,6 +479,37 @@ export class CustomMcpManager {
         entry.config.enabled = false;
         await this.disconnect(entry);
     }
+    syncRepository() {
+        if (this.closed)
+            return;
+        const configs = this.repository.list();
+        const ids = new Set(configs.map((config) => config.id));
+        for (const [id, previous] of this.entries) {
+            if (ids.has(id))
+                continue;
+            this.entries.delete(id);
+            this.repository.delete(id);
+            void this.dispose(previous);
+        }
+        for (const config of configs) {
+            const existing = this.entries.get(config.id);
+            if (!existing) {
+                const entry = newEntry(config);
+                this.entries.set(config.id, entry);
+                if (config.enabled)
+                    void this.connect(entry);
+                continue;
+            }
+            if (JSON.stringify(existing.config) === JSON.stringify(config))
+                continue;
+            const replacement = newEntry(config);
+            this.entries.set(config.id, replacement);
+            void this.dispose(existing).then(() => {
+                if (config.enabled && this.entries.get(config.id) === replacement)
+                    return this.connect(replacement);
+            });
+        }
+    }
     require(id) {
         const entry = this.entries.get(id);
         if (!entry)

package/dist/mcp/server/plugin-mcp-registrar.d.ts

@@ -25,7 +25,10 @@ export declare class PluginMcpRegistrar {
     private readonly operations;
     private readonly pluginId;
     private readonly toolControl;
-    constructor(server: McpServer | null, operations: OperationLog, pluginId: string, toolControl: McpToolControl);
+    private readonly options;
+    constructor(server: McpServer | null, operations: OperationLog, pluginId: string, toolControl: McpToolControl, options?: {
+        agentMode?: boolean;
+    });
     registerTool<InputSchema extends StandardSchemaWithJSON, OutputSchema extends StandardSchemaWithJSON>(name: string, config: PluginToolConfig<InputSchema, OutputSchema>, handler: (input: PluginToolInput<InputSchema>, execution: PluginToolExecution) => Promise<unknown> | unknown): void;
 }
 export {};

package/dist/mcp/server/plugin-mcp-registrar.js

@@ -5,11 +5,13 @@ export class PluginMcpRegistrar {
     operations;
     pluginId;
     toolControl;
-    constructor(server, operations, pluginId, toolControl) {
+    options;
+    constructor(server, operations, pluginId, toolControl, options = {}) {
         this.server = server;
         this.operations = operations;
         this.pluginId = pluginId;
         this.toolControl = toolControl;
+        this.options = options;
     }
     registerTool(name, config, handler) {
         this.toolControl.define({
@@ -17,6 +19,9 @@ export class PluginMcpRegistrar {
             pluginId: this.pluginId,
             title: config.title,
             description: config.description,
+            ...(this.options.agentMode
+                ? { agentAllowed: this.pluginId !== "agent" }
+                : {}),
         });
         if (!this.server)
             return;
@@ -24,7 +29,7 @@ export class PluginMcpRegistrar {
         const callback = mcpTool(async (input) => {
             const operation = this.operations.start({
                 pluginId: this.pluginId,
-                source: "mcp",
+                source: this.options.agentMode ? "agent_mcp" : "mcp",
                 action: typeof action === "function" ? action(input) : action,
                 input: audit?.input ? audit.input(input) : input,
                 ...operationReferences(input),

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

@@ -10,6 +10,7 @@ export interface McpToolSummary {
     title: string;
     description: string;
     enabled: boolean;
+    agentAllowed?: boolean;
 }
 interface McpToolDefinition {
     name: string;
@@ -17,17 +18,21 @@ interface McpToolDefinition {
     title: string;
     description: string;
     defaultEnabled?: boolean;
+    /** Prevent a gateway from exposing management tools to the agent itself. */
+    agentAllowed?: boolean;
 }
 export declare class McpToolControl {
     private readonly store;
+    private readonly defaultEnabled;
     private readonly disabled;
     private readonly configured;
     private readonly definitions;
     private readonly handles;
-    constructor(store: McpToolSettingStore);
+    constructor(store: McpToolSettingStore, defaultEnabled?: boolean);
     define(definition: McpToolDefinition): void;
     undefine(name: string): void;
     isEnabled(name: string): boolean;
+    definition(name: string): Readonly<McpToolDefinition> | null;
     attach(name: string, tool: RegisteredTool): void;
     list(): McpToolSummary[];
     setEnabled(name: string, enabled: boolean): McpToolSummary;

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

@@ -1,12 +1,14 @@
 import { ChatRoomError } from "#core/errors/chatroom-error";
 export class McpToolControl {
     store;
+    defaultEnabled;
     disabled = new Set();
     configured = new Set();
     definitions = new Map();
     handles = new Map();
-    constructor(store) {
+    constructor(store, defaultEnabled = true) {
         this.store = store;
+        this.defaultEnabled = defaultEnabled;
         for (const name of store.disabledTools())
             this.disabled.add(name);
         for (const name of store.configuredTools?.() ?? [])
@@ -17,7 +19,9 @@ export class McpToolControl {
         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 &&
+        if ((definition.defaultEnabled === false ||
+            !this.defaultEnabled ||
+            definition.agentAllowed === false) &&
             !this.configured.has(definition.name))
             this.setEnabled(definition.name, false);
     }
@@ -31,6 +35,9 @@ export class McpToolControl {
     isEnabled(name) {
         return this.definitions.has(name) && !this.disabled.has(name);
     }
+    definition(name) {
+        return this.definitions.get(name) ?? null;
+    }
     attach(name, tool) {
         let tools = this.handles.get(name);
         if (!tools) {
@@ -59,6 +66,8 @@ export class McpToolControl {
         const definition = this.definitions.get(name);
         if (!definition)
             throw new ChatRoomError("NOT_FOUND", `Unknown MCP tool: ${name}`);
+        if (enabled && definition.agentAllowed === false)
+            throw new ChatRoomError("FORBIDDEN", `Tool is not available to Agent MCP: ${name}`);
         if (enabled === !this.disabled.has(name))
             return { ...definition, enabled };
         this.store.setEnabled(name, enabled);

package/dist/plugins/agent/custom-mcp-store.d.ts

@@ -0,0 +1,17 @@
+import type { CustomMcpRepository } from "#infrastructure/database/custom-mcp-repository";
+import type { AgentMcpSettingsRepository } from "#infrastructure/database/agent-mcp-settings-repository";
+import type { CustomMcpConfig, CustomMcpStore } from "#mcp/custom/types";
+/**
+ * Shares server definitions and credentials with ChatRoom MCP, but owns the
+ * Agent-specific enabled state. Updating an Agent toggle never changes the
+ * enabled column in custom_mcp_servers.
+ */
+export declare class AgentCustomMcpStore implements CustomMcpStore {
+    private readonly servers;
+    private readonly settings;
+    constructor(servers: CustomMcpRepository, settings: AgentMcpSettingsRepository);
+    list(): CustomMcpConfig[];
+    save(config: CustomMcpConfig): void;
+    delete(id: string): void;
+    private serverSettingId;
+}

package/dist/plugins/agent/custom-mcp-store.js

@@ -0,0 +1,38 @@
+/**
+ * Shares server definitions and credentials with ChatRoom MCP, but owns the
+ * Agent-specific enabled state. Updating an Agent toggle never changes the
+ * enabled column in custom_mcp_servers.
+ */
+export class AgentCustomMcpStore {
+    servers;
+    settings;
+    constructor(servers, settings) {
+        this.servers = servers;
+        this.settings = settings;
+    }
+    list() {
+        return this.servers.list().map((server) => ({
+            ...server,
+            enabled: this.settings.serverEnabled(this.serverSettingId(server.id)),
+        }));
+    }
+    save(config) {
+        const existing = this.servers
+            .list()
+            .find((server) => server.id === config.id);
+        this.servers.save({
+            ...config,
+            // Keep the ChatRoom MCP preference independent from the Agent preference.
+            enabled: existing?.enabled ?? false,
+        });
+        this.settings.setServerEnabled(this.serverSettingId(config.id), config.enabled);
+    }
+    delete(id) {
+        // Agent settings may be cleared independently; the shared server definition
+        // belongs to the ChatRoom MCP configuration and is never deleted here.
+        this.settings.deleteServerSetting(this.serverSettingId(id));
+    }
+    serverSettingId(id) {
+        return "custom:" + id;
+    }
+}

package/dist/plugins/agent/mcp-gateway.d.ts

@@ -0,0 +1,16 @@
+import { McpServer } from "@modelcontextprotocol/server";
+export interface AgentMcpConnection {
+    url: string;
+    token: string;
+}
+export declare class AgentMcpGateway {
+    private readonly createServerForRequest;
+    private server;
+    private readonly token;
+    private connectionValue;
+    constructor(createServerForRequest: () => McpServer);
+    connection(): AgentMcpConnection;
+    start(): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function createAgentMcpServer(register: (server: McpServer) => void): McpServer;

package/dist/plugins/agent/mcp-gateway.js

@@ -0,0 +1,110 @@
+import { randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { McpServer, createMcpHandler } from "@modelcontextprotocol/server";
+import { toNodeHandler } from "@modelcontextprotocol/node";
+import { CHATROOM_VERSION } from "#core/runtime/identity";
+export class AgentMcpGateway {
+    createServerForRequest;
+    server = null;
+    token = randomBytes(32).toString("base64url");
+    connectionValue = null;
+    constructor(createServerForRequest) {
+        this.createServerForRequest = createServerForRequest;
+    }
+    connection() {
+        if (!this.connectionValue)
+            throw new Error("Agent MCP gateway has not started");
+        return { ...this.connectionValue };
+    }
+    async start() {
+        if (this.server)
+            return;
+        const handler = createMcpHandler(() => this.createServerForRequest(), {
+            legacy: "stateless",
+            responseMode: "auto",
+        });
+        const nodeHandler = toNodeHandler(handler);
+        const server = createServer((req, res) => {
+            const host = req.headers.host;
+            let hostName = "";
+            try {
+                hostName = new URL("http://" + (host ?? "")).hostname;
+            }
+            catch {
+                /* reject below */
+            }
+            if (!["localhost", "127.0.0.1", "[::1]", "::1"].includes(hostName)) {
+                res.writeHead(403).end();
+                return;
+            }
+            const origin = req.headers.origin;
+            if (origin) {
+                let originHost = "";
+                try {
+                    originHost = new URL(origin).hostname;
+                }
+                catch {
+                    /* reject below */
+                }
+                if (!["localhost", "127.0.0.1", "[::1]", "::1"].includes(originHost)) {
+                    res.writeHead(403).end();
+                    return;
+                }
+            }
+            if (req.url !== "/mcp") {
+                res.writeHead(404).end();
+                return;
+            }
+            const authorization = req.headers.authorization ?? "";
+            if (authorization !== "Bearer " + this.token) {
+                res
+                    .writeHead(401, {
+                    "WWW-Authenticate": "Bearer",
+                    "Cache-Control": "no-store",
+                })
+                    .end();
+                return;
+            }
+            void nodeHandler(req, res);
+        });
+        this.server = server;
+        try {
+            await new Promise((resolve, reject) => {
+                server.once("error", reject);
+                server.listen(0, "127.0.0.1", () => {
+                    server.off("error", reject);
+                    resolve();
+                });
+            });
+            const address = server.address();
+            if (!address || typeof address === "string")
+                throw new Error("Agent MCP gateway did not bind a TCP port");
+            this.connectionValue = {
+                url: `http://127.0.0.1:${address.port}/mcp`,
+                token: this.token,
+            };
+        }
+        catch (error) {
+            this.server = null;
+            server.close();
+            throw error;
+        }
+    }
+    async close() {
+        const server = this.server;
+        this.server = null;
+        this.connectionValue = null;
+        if (!server?.listening)
+            return;
+        server.closeAllConnections();
+        await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+    }
+}
+export function createAgentMcpServer(register) {
+    const server = new McpServer({
+        name: "chatroom-agent-mcp",
+        version: CHATROOM_VERSION,
+    });
+    register(server);
+    return server;
+}

package/dist/plugins/agent/mcp.js

@@ -79,7 +79,8 @@ const capabilities = z
     .nullable();
 const session = z.object({
     id: z.string(),
-    workspaceRoot: z.string(),
+    workspaceId: z.string(),
+    workspaceName: z.string(),
     provider,
     ...settings,
     tokenUsage: tokenUsage.nullable(),
@@ -354,7 +355,7 @@ export function registerAgentTools(mcp, agents) {
         title: "Create Agent session",
         description: "Create an Agent session for a ChatRoom workspace using a registered provider. Choose settings from agent_models and agent_providers capabilities; omitted or null settings use provider/model defaults.",
         inputSchema: z.object({
-            workspaceRoot: z.string().min(1),
+            workspaceId: z.string().min(1),
             provider,
             model: settings.model.default(null),
             reasoningEffort: settings.reasoningEffort.default(null),

package/dist/plugins/agent/plugin.js

@@ -11,7 +11,7 @@ export function createAgentPlugin() {
     return {
         id: "agent",
         async activate(context) {
-            runtime = new AgentRuntime(new AgentRepository(context.database), context.services.require(WorkspaceAccessToken), context.events, createAgentProviders(context.logs));
+            runtime = new AgentRuntime(new AgentRepository(context.database), context.services.require(WorkspaceAccessToken), context.events, createAgentProviders(context.logs, context.agentMcp));
             await runtime.cleanupOrphanAttachments();
             attachmentCleanupTimer = setInterval(() => {
                 void runtime?.cleanupOrphanAttachments().catch(() => undefined);

package/dist/plugins/agent/provider.d.ts

@@ -17,6 +17,7 @@ export interface AgentProvider {
     createSession(context: AgentProviderContext): Promise<ProviderSession>;
     resumeSession(context: AgentProviderContext, providerSessionId: string): Promise<ProviderSession>;
     close(): Promise<void>;
+    refreshMcpServers?(): Promise<void>;
 }
 export interface ProviderSession {
     readonly providerSessionId: string;

package/dist/plugins/agent/providers/codex/launch.d.ts

@@ -0,0 +1,17 @@
+interface CodexLaunch {
+    command: string;
+    args: string[];
+}
+interface CodexLaunchOptions {
+    platform?: NodeJS.Platform;
+    path?: string;
+    nodeExecutable?: string;
+    exists?: (path: string) => boolean;
+}
+/**
+ * npm exposes codex.cmd on Windows, which child_process.spawn cannot execute
+ * without a shell. Launch the installed JS entry point directly with Node.
+ * Prefer an actual executable when one is present earlier on PATH.
+ */
+export declare function resolveCodexLaunch({ platform, path, nodeExecutable, exists, }?: CodexLaunchOptions): CodexLaunch;
+export {};

package/dist/plugins/agent/providers/codex/launch.js

@@ -0,0 +1,24 @@
+import { existsSync } from "node:fs";
+import { win32 } from "node:path";
+/**
+ * npm exposes codex.cmd on Windows, which child_process.spawn cannot execute
+ * without a shell. Launch the installed JS entry point directly with Node.
+ * Prefer an actual executable when one is present earlier on PATH.
+ */
+export function resolveCodexLaunch({ platform = process.platform, path = process.env.PATH ?? "", nodeExecutable = process.execPath, exists = existsSync, } = {}) {
+    if (platform !== "win32")
+        return { command: "codex", args: [] };
+    for (const entry of path.split(";")) {
+        const directory = entry.trim().replace(/^"|"$/g, "");
+        if (!directory)
+            continue;
+        const executable = win32.join(directory, "codex.exe");
+        if (exists(executable))
+            return { command: executable, args: [] };
+        const npmShim = win32.join(directory, "codex.cmd");
+        const npmEntry = win32.join(directory, "node_modules", "@openai", "codex", "bin", "codex.js");
+        if (exists(npmShim) && exists(npmEntry))
+            return { command: nodeExecutable, args: [npmEntry] };
+    }
+    return { command: "codex", args: [] };
+}

package/dist/plugins/agent/providers/codex/provider.d.ts

@@ -1,6 +1,7 @@
 import type { LogWriter } from "#core/logging/types";
 import type { AgentProvider, AgentProviderContext, ProviderSession } from "#plugins/agent/provider";
 import type { AgentModel, AgentProviderProbe, AgentProviderDetails } from "#plugins/agent/types";
+import { type CodexMcpConnection } from "./rpc.js";
 export declare class CodexProvider implements AgentProvider {
     private readonly logs;
     readonly id = "codex";
@@ -73,12 +74,13 @@ export declare class CodexProvider implements AgentProvider {
     }];
     private readonly client;
     private readonly modelNames;
-    constructor(logs: LogWriter);
+    constructor(logs: LogWriter, mcpConnection?: CodexMcpConnection);
     probe(): Promise<AgentProviderProbe>;
     details(): Promise<AgentProviderDetails>;
     listModels(): Promise<AgentModel[]>;
     createSession(context: AgentProviderContext): Promise<ProviderSession>;
     resumeSession(context: AgentProviderContext, providerSessionId: string): Promise<ProviderSession>;
     private resolveModel;
+    refreshMcpServers(): Promise<void>;
     close(): Promise<void>;
 }

package/dist/plugins/agent/providers/codex/provider.js

@@ -88,9 +88,12 @@ export class CodexProvider {
     ];
     client;
     modelNames = new Map();
-    constructor(logs) {
+    constructor(logs, mcpConnection = {
+        url: "http://127.0.0.1:1/mcp",
+        token: "test-only-token",
+    }) {
         this.logs = logs;
-        this.client = new CodexRpcClient(logs);
+        this.client = new CodexRpcClient(logs, mcpConnection);
     }
     async probe() {
         try {
@@ -219,6 +222,9 @@ export class CodexProvider {
             throw new Error("Unknown Codex model: " + modelId);
         return model.model;
     }
+    async refreshMcpServers() {
+        await this.client.reloadMcpConfiguration();
+    }
     close() {
         return this.client.close();
     }

package/dist/plugins/agent/providers/codex/rpc.d.ts

@@ -10,8 +10,13 @@ export interface CodexServerRequest extends CodexNotification {
 interface InitializeResult {
     userAgent: string;
 }
+export interface CodexMcpConnection {
+    url: string;
+    token: string;
+}
 export declare class CodexRpcClient {
     private readonly logs;
+    private readonly mcpConnection;
     private process;
     private readonly pending;
     private readonly notificationListeners;
@@ -20,9 +25,10 @@ export declare class CodexRpcClient {
     private nextId;
     private starting;
     private initialized;
-    constructor(logs: LogWriter);
+    constructor(logs: LogWriter, mcpConnection?: CodexMcpConnection);
     ensureStarted(): Promise<InitializeResult>;
     request<T>(method: string, params?: unknown, timeoutMs?: number): Promise<T>;
+    reloadMcpConfiguration(): Promise<void>;
     notify(method: string, params?: unknown): void;
     respond(id: CodexRequestId, result: unknown): void;
     respondError(id: CodexRequestId, code: number, message: string): void;

package/dist/plugins/agent/providers/codex/rpc.js

@@ -1,8 +1,10 @@
 import { LineProcess } from "#core/runtime/line-process";
 import { CHATROOM_VERSION } from "#core/runtime/identity";
+import { resolveCodexLaunch } from "./launch.js";
 const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
 export class CodexRpcClient {
     logs;
+    mcpConnection;
     process = null;
     pending = new Map();
     notificationListeners = new Set();
@@ -11,8 +13,12 @@ export class CodexRpcClient {
     nextId = 1;
     starting = null;
     initialized = null;
-    constructor(logs) {
+    constructor(logs, mcpConnection = {
+        url: "http://127.0.0.1:1/mcp",
+        token: "test-only-token",
+    }) {
         this.logs = logs;
+        this.mcpConnection = mcpConnection;
     }
     async ensureStarted() {
         if (this.initialized)
@@ -31,6 +37,13 @@ export class CodexRpcClient {
         await this.ensureStarted();
         return this.requestReady(method, params, timeoutMs);
     }
+    async reloadMcpConfiguration() {
+        // Before Codex starts, the MCP config passed on its command line will be
+        // picked up by the initial connection; avoid spawning Codex just for UI toggles.
+        if (!this.initialized)
+            return;
+        await this.requestReady("config/mcpServer/reload", {});
+    }
     notify(method, params) {
         this.write(params === undefined ? { method } : { method, params });
     }
@@ -62,10 +75,22 @@ export class CodexRpcClient {
         process.forceKill();
     }
     async start() {
+        const launch = resolveCodexLaunch();
         let process;
         process = new LineProcess({
-            command: "codex",
-            args: ["app-server", "--listen", "stdio://", "-c", "mcp_servers={}"],
+            command: launch.command,
+            args: [
+                ...launch.args,
+                "app-server",
+                "--listen",
+                "stdio://",
+                "-c",
+                "mcp_servers.chatroom_agent.url=" +
+                    JSON.stringify(this.mcpConnection.url),
+                "-c",
+                'mcp_servers.chatroom_agent.bearer_token_env_var="CHATROOM_AGENT_MCP_TOKEN"',
+            ],
+            env: { CHATROOM_AGENT_MCP_TOKEN: this.mcpConnection.token },
             onStdout: (line) => this.handleLine(line),
             onStderr: (line) => {
                 const message = line.trim();

package/dist/plugins/agent/providers/index.d.ts

@@ -1,3 +1,4 @@
 import type { LogWriter } from "#core/logging/types";
 import type { AgentProvider } from "../provider.js";
-export declare function createAgentProviders(logs: LogWriter): AgentProvider[];
+import type { AgentMcpConnection } from "../mcp-gateway.js";
+export declare function createAgentProviders(logs: LogWriter, mcpConnection?: AgentMcpConnection): AgentProvider[];

package/dist/plugins/agent/providers/index.js

@@ -1,4 +1,7 @@
 import { CodexProvider } from "./codex/provider.js";
-export function createAgentProviders(logs) {
-    return [new CodexProvider(logs)];
+export function createAgentProviders(logs, mcpConnection = {
+    url: "http://127.0.0.1:1/mcp",
+    token: "test-only-token",
+}) {
+    return [new CodexProvider(logs, mcpConnection)];
 }