@chatroomcp/chatroom 0.1.4 → 0.1.6

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

@@ -0,0 +1,26 @@
+import type { McpServer, StandardSchemaWithJSON, ToolAnnotations } from "@modelcontextprotocol/server";
+import type { OperationLog } from "../../operations/operation-log.js";
+type PluginToolInput<Schema extends StandardSchemaWithJSON> = StandardSchemaWithJSON.InferOutput<Schema>;
+type PluginToolAction<Input> = string | ((input: Input) => string);
+export interface PluginToolExecution {
+    readonly operationId: string;
+    /** Keep the operation running after the MCP handler returns. The owner must finish it later. */
+    deferCompletion(): void;
+}
+export interface PluginToolConfig<InputSchema extends StandardSchemaWithJSON, OutputSchema extends StandardSchemaWithJSON> {
+    title: string;
+    description: string;
+    inputSchema: InputSchema;
+    outputSchema: OutputSchema;
+    annotations: ToolAnnotations;
+    action: PluginToolAction<PluginToolInput<InputSchema>>;
+}
+/** Framework-owned MCP registration boundary that guarantees every plugin tool is audited. */
+export declare class PluginMcpRegistrar {
+    private readonly server;
+    private readonly operations;
+    private readonly pluginId;
+    constructor(server: McpServer, operations: OperationLog, pluginId: string);
+    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

@@ -0,0 +1,63 @@
+import { asChatRoomError } from "../../core/errors/chatroom-error.js";
+import { mcpTool } from "./tool-support.js";
+/** Framework-owned MCP registration boundary that guarantees every plugin tool is audited. */
+export class PluginMcpRegistrar {
+    server;
+    operations;
+    pluginId;
+    constructor(server, operations, pluginId) {
+        this.server = server;
+        this.operations = operations;
+        this.pluginId = pluginId;
+    }
+    registerTool(name, config, handler) {
+        const { action, ...toolConfig } = config;
+        const callback = mcpTool(async (input) => {
+            const operation = this.operations.start({
+                pluginId: this.pluginId,
+                source: "mcp",
+                action: typeof action === "function" ? action(input) : action,
+                input,
+                ...operationReferences(input),
+            });
+            let deferred = false;
+            const execution = {
+                operationId: operation.operationId,
+                deferCompletion() {
+                    deferred = true;
+                },
+            };
+            try {
+                const result = await handler(input, execution);
+                if (!deferred)
+                    this.operations.finish(operation.operationId, "success", result);
+                return result;
+            }
+            catch (error) {
+                if (this.operations.get(operation.operationId)?.status === "running") {
+                    const normalized = asChatRoomError(error);
+                    this.operations.finish(operation.operationId, "error", null, {
+                        code: normalized.code,
+                        message: normalized.message,
+                        details: normalized.details,
+                    });
+                }
+                throw error;
+            }
+        });
+        this.server.registerTool(name, toolConfig, callback);
+    }
+}
+function operationReferences(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return {};
+    const record = input;
+    return {
+        ...(typeof record.workspaceId === "string"
+            ? { workspaceId: record.workspaceId }
+            : {}),
+        ...(typeof record.processId === "string"
+            ? { processId: record.processId }
+            : {}),
+    };
+}

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

@@ -35,8 +35,8 @@ export declare const workspaceOutputSchema: z.ZodObject<{
     root: z.ZodString;
     sourceRoot: z.ZodString;
     mode: z.ZodEnum<{
-        worktree: "worktree";
         checkout: "checkout";
+        worktree: "worktree";
     }>;
     createdAt: z.ZodString;
     lastUsedAt: z.ZodString;

package/dist/operations/operation-log.d.ts

@@ -14,6 +14,10 @@ export declare class OperationLog {
     run<T>(request: OperationStart, action: () => Promise<T>): Promise<T>;
     list(query?: OperationQuery): Operation[];
     get(operationId: string): Operation | null;
+    associate(operationId: string, references: {
+        workspaceId?: string | null;
+        processId?: string | null;
+    }): Operation;
     clearHistory(): {
         deleted: number;
         preserved: number;

package/dist/operations/operation-log.js

@@ -86,6 +86,16 @@ export class OperationLog {
     get(operationId) {
         return this.repository.get(operationId);
     }
+    associate(operationId, references) {
+        const operation = this.require(operationId);
+        if (references.workspaceId !== undefined)
+            operation.workspaceId = references.workspaceId;
+        if (references.processId !== undefined)
+            operation.processId = references.processId;
+        this.repository.update(operation);
+        this.eventBus.emit({ type: "operation", operation });
+        return operation;
+    }
     clearHistory() {
         const result = this.repository.clearHistory();
         this.eventBus.emit({ type: "operations-cleared", ...result });

package/dist/plugins/cloud/api-client.d.ts

@@ -25,11 +25,6 @@ declare const restoreSchema: z.ZodObject<{
     publicPrefix: z.ZodNullable<z.ZodString>;
     recoveryKey: z.ZodString;
 }, z.core.$strict>;
-declare const prefixSchema: z.ZodObject<{
-    publicPrefix: z.ZodString;
-    mcpUrl: z.ZodString;
-    webUrl: z.ZodString;
-}, z.core.$strict>;
 export declare class CloudApiClient {
     private readonly baseUrl;
     constructor(baseUrl: string);
@@ -44,7 +39,6 @@ export declare class CloudApiClient {
     }>;
     restore(identity: DeviceIdentity, recoveryKey: string): Promise<z.infer<typeof restoreSchema>>;
     replaceRecoveryKey(identity: DeviceIdentity): Promise<z.infer<typeof recoveryCredentialSchema>>;
-    setPrefix(identity: DeviceIdentity, prefix: string): Promise<z.infer<typeof prefixSchema>>;
     lease(identity: DeviceIdentity, requestedServices: CloudServiceId[]): Promise<CloudLeaseState>;
     private devicePost;
 }

package/dist/plugins/cloud/api-client.js

@@ -30,13 +30,6 @@ const restoreSchema = z
     recoveryKey: z.string().regex(/^crr\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/),
 })
     .strict();
-const prefixSchema = z
-    .object({
-    publicPrefix: z.string().min(1),
-    mcpUrl: z.string().url(),
-    webUrl: z.string().url(),
-})
-    .strict();
 export class CloudApiClient {
     baseUrl;
     constructor(baseUrl) {
@@ -61,10 +54,6 @@ export class CloudApiClient {
         const payload = { devicePublicKey: identity.devicePublicKey };
         return recoveryCredentialSchema.parse(await this.devicePost("/v1/device/recovery-key", "recovery-key", identity, payload));
     }
-    async setPrefix(identity, prefix) {
-        const payload = { devicePublicKey: identity.devicePublicKey, prefix };
-        return prefixSchema.parse(await this.devicePost("/v1/device/prefix", "prefix", identity, payload));
-    }
     async lease(identity, requestedServices) {
         const payload = {
             devicePublicKey: identity.devicePublicKey,

package/dist/plugins/cloud/controller.d.ts

@@ -34,7 +34,6 @@ export declare class CloudController {
         recoveryKey: string;
     }>;
     replaceRecoveryKey(): Promise<string>;
-    setPrefix(prefix: string): Promise<CloudStatus>;
     setService(service: CloudServiceId, enabled: boolean): Promise<CloudStatus>;
     private refreshLeaseIfNeeded;
     private connectTunnel;

package/dist/plugins/cloud/controller.js

@@ -134,18 +134,6 @@ export class CloudController {
         const result = await this.api.replaceRecoveryKey(this.identity());
         return result.recoveryKey;
     }
-    async setPrefix(prefix) {
-        const result = await this.api.setPrefix(this.identity(), prefix);
-        this.state = { ...this.state, publicPrefix: result.publicPrefix };
-        await this.store.save(this.state);
-        if (!this.stopped && this.state.entitlements.length > 0) {
-            await this.refreshLeaseIfNeeded(true);
-            this.connectTunnel();
-            this.scheduleRenewal();
-        }
-        this.lastError = null;
-        return this.status();
-    }
     async setService(service, enabled) {
         if (!CLOUD_SERVICES.includes(service))
             throw new Error(`Unknown Cloud service: ${service}`);

package/dist/plugins/cloud/tunnel-client.js

@@ -59,14 +59,21 @@ export class CloudTunnelClient {
         this.closeWhenIdle = "stop";
     }
     updateLease(lease) {
-        const previousServices = this.lease.services;
-        const reconnect = lease.token !== this.lease.token ||
-            lease.tunnelUrl !== this.lease.tunnelUrl;
-        const removesService = previousServices.some((service) => !lease.services.includes(service));
+        const tunnelChanged = lease.tunnelUrl !== this.lease.tunnelUrl;
+        const removesService = this.lease.services.some((service) => !lease.services.includes(service));
         this.lease = lease;
         this.acceptingServices = new Set(lease.services);
-        if (!reconnect || this.stopped)
+        if (this.stopped)
             return;
+        // A new signed lease on the same tunnel is applied in-band. This keeps the
+        // current WebUI/API request alive while service permissions change.
+        if (!tunnelChanged) {
+            if (this.socket?.readyState === WebSocket.OPEN)
+                this.send({ type: "update-lease", lease: lease.token });
+            return;
+        }
+        // Changing the tunnel endpoint still requires a reconnect. If a service is
+        // being removed, let current streams finish before moving the connection.
         if (!removesService || this.streams.size === 0) {
             this.socket?.close();
             return;

package/dist/plugins/plugin-manager.js

@@ -1,3 +1,4 @@
+import { PluginMcpRegistrar } from "../mcp/server/plugin-mcp-registrar.js";
 export class PluginManager {
     context;
     plugins;
@@ -13,8 +14,11 @@ export class PluginManager {
         }
     }
     registerMcp(server) {
-        for (const plugin of this.active)
-            plugin.registerMcp?.(server);
+        for (const plugin of this.active) {
+            if (!plugin.registerMcp)
+                continue;
+            plugin.registerMcp(new PluginMcpRegistrar(server, this.context.operations, plugin.id));
+        }
     }
     async stop() {
         for (const plugin of [...this.active].reverse())

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

@@ -1,4 +1,3 @@
-import type { McpServer } from "@modelcontextprotocol/server";
-import type { OperationLog } from "../../operations/operation-log.js";
+import type { PluginMcpRegistrar } from "../../mcp/server/plugin-mcp-registrar.js";
 import type { ProcessSupervisor } from "./process-supervisor.js";
-export declare function registerProcessTools(server: McpServer, processes: ProcessSupervisor, operations: OperationLog): void;
+export declare function registerProcessTools(mcp: PluginMcpRegistrar, processes: ProcessSupervisor): void;

package/dist/plugins/process/mcp.js

@@ -1,9 +1,9 @@
 import { z } from "zod";
-import { closedRead, destructiveLocalMutation, mcpTool, openWorldMutation, processSnapshotSchema, } from "../../mcp/server/tool-support.js";
-export function registerProcessTools(server, processes, operations) {
-    server.registerTool("process_start", {
+import { closedRead, destructiveLocalMutation, openWorldMutation, processSnapshotSchema, } from "../../mcp/server/tool-support.js";
+export function registerProcessTools(mcp, processes) {
+    mcp.registerTool("process_start", {
         title: "Start process",
-        description: "Start a supervised pipe or PTY process. Returns a ProcessId immediately.",
+        description: "Start a supervised executable directly and return a ProcessId immediately. Prefer invoking the target executable without a shell. For compound shell commands, use bash -c rather than bash -lc unless login-shell semantics are explicitly required, because a login shell may replace the inherited PATH (for example, removing NVM-managed Node.js commands).",
         inputSchema: z.object({
             command: z.string().min(1),
             args: z.array(z.string()).default([]),
@@ -14,43 +14,37 @@ export function registerProcessTools(server, processes, operations) {
         }),
         outputSchema: processSnapshotSchema,
         annotations: openWorldMutation,
-    }, mcpTool((input) => processes.start({
-        cwd: input.cwd,
-        command: input.command,
-        args: input.args,
-        ...(input.env ? { env: input.env } : {}),
-        pty: input.pty,
-        ...(input.timeoutMs === undefined
-            ? {}
-            : { timeoutMs: input.timeoutMs }),
-    }, { source: "mcp" })));
-    server.registerTool("process_read", {
+        action: "start",
+    }, (input, execution) => {
+        execution.deferCompletion();
+        return processes.start({
+            cwd: input.cwd,
+            command: input.command,
+            args: input.args,
+            ...(input.env ? { env: input.env } : {}),
+            pty: input.pty,
+            ...(input.timeoutMs === undefined
+                ? {}
+                : { timeoutMs: input.timeoutMs }),
+        }, { source: "mcp", operationId: execution.operationId });
+    });
+    mcp.registerTool("process_read", {
         title: "Read process",
         description: "Read bounded stdout/stderr and current process state.",
         inputSchema: z.object({ processId: z.string() }),
         outputSchema: processSnapshotSchema,
         annotations: closedRead,
-    }, mcpTool((input) => operations.run({
-        pluginId: "process",
-        source: "mcp",
         action: "read",
-        processId: input.processId,
-        input,
-    }, () => Promise.resolve(processes.read(input.processId)))));
-    server.registerTool("process_write", {
+    }, (input) => processes.read(input.processId));
+    mcp.registerTool("process_write", {
         title: "Write process stdin",
         description: "Write to stdin of a running process.",
         inputSchema: z.object({ processId: z.string(), data: z.string() }),
         outputSchema: processSnapshotSchema,
         annotations: openWorldMutation,
-    }, mcpTool((input) => operations.run({
-        pluginId: "process",
-        source: "mcp",
         action: "write",
-        processId: input.processId,
-        input,
-    }, () => Promise.resolve(processes.write(input.processId, input.data)))));
-    server.registerTool("process_kill", {
+    }, (input) => processes.write(input.processId, input.data));
+    mcp.registerTool("process_kill", {
         title: "Stop process",
         description: "Terminate or force-kill a supervised process.",
         inputSchema: z.object({
@@ -59,11 +53,6 @@ export function registerProcessTools(server, processes, operations) {
         }),
         outputSchema: processSnapshotSchema,
         annotations: destructiveLocalMutation,
-    }, mcpTool((input) => operations.run({
-        pluginId: "process",
-        source: "mcp",
-        action: input.force ? "kill" : "terminate",
-        processId: input.processId,
-        input,
-    }, () => Promise.resolve(processes.kill(input.processId, input.force)))));
+        action: (input) => (input.force ? "kill" : "terminate"),
+    }, (input) => processes.kill(input.processId, input.force));
 }

package/dist/plugins/process/plugin.js

@@ -6,23 +6,20 @@ import { ProcessSupervisor } from "./process-supervisor.js";
 export const ProcessService = createServiceToken("process");
 export function createProcessPlugin() {
     let service = null;
-    let operations = null;
     return {
         id: "process",
         activate(context) {
             service = new ProcessSupervisor({ pipe: new PipeProcessBackend(), pty: new PtyProcessBackend() }, context.operations, context.events, context.config.process.maxOutputBytes, context.config.process.defaultTimeoutMs, context.config.process.maxCompletedProcesses);
-            operations = context.operations;
             context.services.provide(ProcessService, service);
         },
-        registerMcp(server) {
-            if (!service || !operations)
+        registerMcp(mcp) {
+            if (!service)
                 throw new Error("Process plugin is not active");
-            registerProcessTools(server, service, operations);
+            registerProcessTools(mcp, service);
         },
         async deactivate() {
             await service?.shutdown();
             service = null;
-            operations = null;
         },
     };
 }

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

@@ -6,6 +6,7 @@ import type { ProcessBackend } from "./backend.js";
 interface ProcessOperationContext {
     source: OperationSource;
     action?: string;
+    operationId?: string;
 }
 export declare class ProcessSupervisor {
     private readonly backends;

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

@@ -28,20 +28,24 @@ export class ProcessSupervisor {
             throw new ChatRoomError("CONFLICT", "Process supervisor is shutting down");
         const processId = `proc_${randomUUID()}`;
         const args = request.args ?? [];
-        const operation = this.operations.start({
-            pluginId: "process",
-            source: operationContext.source,
-            action: operationContext.action ?? "start",
-            processId,
-            input: {
-                command: request.command,
-                args,
-                cwd: request.cwd,
-                pty: request.pty ?? false,
-                timeoutMs: request.timeoutMs ?? this.defaultTimeoutMs,
-                env: request.env ?? {},
-            },
-        });
+        const adoptedOperation = operationContext.operationId !== undefined;
+        const operationId = operationContext.operationId ??
+            this.operations.start({
+                pluginId: "process",
+                source: operationContext.source,
+                action: operationContext.action ?? "start",
+                processId,
+                input: {
+                    command: request.command,
+                    args,
+                    cwd: request.cwd,
+                    pty: request.pty ?? false,
+                    timeoutMs: request.timeoutMs ?? this.defaultTimeoutMs,
+                    env: request.env ?? {},
+                },
+            }).operationId;
+        if (adoptedOperation)
+            this.operations.associate(operationId, { processId });
         let backend;
         try {
             // Child environments inherit only the runtime allowlist, then apply explicit request overrides.
@@ -51,7 +55,8 @@ export class ProcessSupervisor {
             });
         }
         catch (error) {
-            this.operations.finish(operation.operationId, "error", null, error);
+            if (!adoptedOperation)
+                this.operations.finish(operationId, "error", null, error);
             throw new ChatRoomError("PROCESS_FAILED", `Failed to start process: ${request.command}`, undefined, { cause: error });
         }
         let resolveSettled;
@@ -71,7 +76,7 @@ export class ProcessSupervisor {
             timeout: null,
             forceTimeout: null,
             timedOut: false,
-            operationId: operation.operationId,
+            operationId,
             settled,
             resolveSettled,
         };

package/dist/plugins/types.d.ts

@@ -1,6 +1,6 @@
-import type { McpServer } from "@modelcontextprotocol/server";
 import type { ChatRoomConfig } from "../config/types.js";
 import type { AppDatabase } from "../infrastructure/database/app-database.js";
+import type { PluginMcpRegistrar } from "../mcp/server/plugin-mcp-registrar.js";
 import type { OperationLog } from "../operations/operation-log.js";
 import type { RuntimeEventBus } from "../app/event-bus.js";
 import type { ExternalAccessRegistry } from "../app/external-access-registry.js";
@@ -27,6 +27,6 @@ export interface PluginContext {
 export interface InternalPlugin {
     id: string;
     activate(context: PluginContext): Promise<void> | void;
-    registerMcp?(server: McpServer): void;
+    registerMcp?(mcp: PluginMcpRegistrar): void;
     deactivate?(): Promise<void> | void;
 }

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

@@ -15,18 +15,6 @@ export function createCloudApiRouter(controller, operations) {
         res.json(await operations.run({ pluginId: "cloud", source: "gui", action: "restore", input: body }, () => controller.restore(body.recoveryKey)));
     }));
     router.post("/cloud/recovery-key", asyncRoute(async (_req, res) => res.json(await operations.run({ pluginId: "cloud", source: "gui", action: "recovery-key.replace" }, async () => ({ recoveryKey: await controller.replaceRecoveryKey() })))));
-    router.post("/cloud/prefix", asyncRoute(async (req, res) => {
-        const body = z
-            .object({ prefix: z.string().min(1).max(64) })
-            .strict()
-            .parse(req.body);
-        res.json(await operations.run({
-            pluginId: "cloud",
-            source: "gui",
-            action: "prefix.set",
-            input: body,
-        }, () => controller.setPrefix(body.prefix)));
-    }));
     router.post("/cloud/services/:service", asyncRoute(async (req, res) => {
         const service = CLOUD_SERVICE_SCHEMA.parse(req.params.service);
         const body = z.object({ enabled: z.boolean() }).strict().parse(req.body);

package/dist/plugins/workspace/mcp.d.ts

@@ -1,4 +1,3 @@
-import type { McpServer } from "@modelcontextprotocol/server";
-import type { OperationLog } from "../../operations/operation-log.js";
+import type { PluginMcpRegistrar } from "../../mcp/server/plugin-mcp-registrar.js";
 import type { WorkspaceService } from "./workspace-service.js";
-export declare function registerWorkspaceTools(server: McpServer, workspaces: WorkspaceService, operations: OperationLog): void;
+export declare function registerWorkspaceTools(mcp: PluginMcpRegistrar, workspaces: WorkspaceService): void;