@chatroomcp/chatroom 0.1.4 → 0.1.5

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

@@ -3,6 +3,10 @@ import { type CloudEntitlement, type CloudLeaseState, type CloudServiceId } from
 declare const recoveryCredentialSchema: z.ZodObject<{
     recoveryKey: z.ZodString;
 }, z.core.$strict>;
+declare const registrationSchema: z.ZodObject<{
+    installationId: z.ZodString;
+    registered: z.ZodLiteral<true>;
+}, z.core.$strict>;
 declare const sessionSchema: z.ZodObject<{
     purchaseToken: z.ZodString;
     managementUrl: z.ZodString;
@@ -33,6 +37,7 @@ declare const prefixSchema: z.ZodObject<{
 export declare class CloudApiClient {
     private readonly baseUrl;
     constructor(baseUrl: string);
+    registerDevice(identity: DeviceIdentity): Promise<z.infer<typeof registrationSchema>>;
     createManagementSession(identity: DeviceIdentity): Promise<z.infer<typeof sessionSchema>>;
     status(identity: DeviceIdentity, purchaseToken: string | null): Promise<{
         managementSessionActive: boolean;

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

@@ -7,6 +7,12 @@ const recoveryCredentialSchema = z
     recoveryKey: z.string().regex(/^crr\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/),
 })
     .strict();
+const registrationSchema = z
+    .object({
+    installationId: z.string().uuid(),
+    registered: z.literal(true),
+})
+    .strict();
 const sessionSchema = z
     .object({
     purchaseToken: z.string().min(24),
@@ -42,6 +48,10 @@ export class CloudApiClient {
     constructor(baseUrl) {
         this.baseUrl = baseUrl;
     }
+    async registerDevice(identity) {
+        const payload = { devicePublicKey: identity.devicePublicKey };
+        return registrationSchema.parse(await this.devicePost("/v1/device/register", "register", identity, payload));
+    }
     async createManagementSession(identity) {
         const payload = { devicePublicKey: identity.devicePublicKey };
         return sessionSchema.parse(await this.devicePost("/v1/device/session", "session", identity, payload));

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

@@ -24,6 +24,7 @@ export declare class CloudController {
     status(): CloudStatus;
     start(): Promise<void>;
     stop(): Promise<void>;
+    registerDevice(): Promise<CloudStatus>;
     managementUrl(): Promise<{
         url: string;
         expiresAt: string;

package/dist/plugins/cloud/controller.js

@@ -65,6 +65,11 @@ export class CloudController {
         if (this.state.lease)
             this.connection = "disconnected";
     }
+    async registerDevice() {
+        await this.api.registerDevice(this.identity());
+        this.lastError = null;
+        return this.status();
+    }
     async managementUrl() {
         const current = this.state.managementSession;
         if (current && Date.parse(current.expiresAt) > Date.now()) {

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

@@ -5,6 +5,7 @@ import { asyncRoute } from "../../../presentation/http/http-utils.js";
 export function createCloudApiRouter(controller, operations) {
     const router = Router();
     router.get("/cloud/status", (_req, res) => res.json(controller.status()));
+    router.post("/cloud/register", asyncRoute(async (_req, res) => res.json(await operations.run({ pluginId: "cloud", source: "gui", action: "register" }, () => controller.registerDevice()))));
     router.post("/cloud/sync", asyncRoute(async (_req, res) => res.json(await operations.run({ pluginId: "cloud", source: "gui", action: "sync" }, () => controller.syncStatus()))));
     router.post("/cloud/management", asyncRoute(async (_req, res) => res.json(await operations.run({ pluginId: "cloud", source: "gui", action: "management" }, () => controller.managementUrl()))));
     router.post("/cloud/restore", asyncRoute(async (req, res) => {

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;

package/dist/plugins/workspace/mcp.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { changeSetSchema, closedRead, destructiveLocalMutation, fileInfoSchema, fileReadOutputSchema, fileWriteOutputSchema, localMutation, localWrite, mcpTool, searchMatchSchema, workspaceOutputSchema, } from "../../mcp/server/tool-support.js";
-export function registerWorkspaceTools(server, workspaces, operations) {
-    server.registerTool("open_workspace", {
+import { changeSetSchema, closedRead, destructiveLocalMutation, fileInfoSchema, fileReadOutputSchema, fileWriteOutputSchema, localMutation, localWrite, searchMatchSchema, workspaceOutputSchema, } from "../../mcp/server/tool-support.js";
+export function registerWorkspaceTools(mcp, workspaces) {
+    mcp.registerTool("open_workspace", {
         title: "Open workspace",
         description: "Open or reuse an approved checkout, or create a new isolated managed Git worktree from the source checkout HEAD.",
         inputSchema: z.object({
@@ -10,11 +10,12 @@ export function registerWorkspaceTools(server, workspaces, operations) {
         }),
         outputSchema: workspaceOutputSchema,
         annotations: localMutation,
-    }, mcpTool((input) => operations.run({ pluginId: "workspace", source: "mcp", action: "open", input }, () => workspaces.open({
+        action: "open",
+    }, (input) => workspaces.open({
         path: input.path,
         ...(input.mode ? { mode: input.mode } : {}),
-    }))));
-    server.registerTool("remove_workspace", {
+    }));
+    mcp.registerTool("remove_workspace", {
         title: "Remove workspace",
         description: "Unregister a checkout workspace or remove a managed worktree. Dirty worktrees require force=true.",
         inputSchema: z.object({
@@ -27,17 +28,12 @@ export function registerWorkspaceTools(server, workspaces, operations) {
             mode: z.enum(["checkout", "worktree"]),
         }),
         annotations: destructiveLocalMutation,
-    }, mcpTool(async (input) => {
-        const removed = await operations.run({
-            pluginId: "workspace",
-            source: "mcp",
-            action: "remove",
-            workspaceId: input.workspaceId,
-            input,
-        }, () => workspaces.remove(input.workspaceId, input.force ?? false));
+        action: "remove",
+    }, async (input) => {
+        const removed = await workspaces.remove(input.workspaceId, input.force ?? false);
         return { removed: true, workspaceId: removed.id, mode: removed.mode };
-    }));
-    server.registerTool("fs_read", {
+    });
+    mcp.registerTool("fs_read", {
         title: "Read file",
         description: "Read a workspace-relative file through the ChatRoom filesystem boundary.",
         inputSchema: z.object({
@@ -52,17 +48,12 @@ export function registerWorkspaceTools(server, workspaces, operations) {
         }),
         outputSchema: fileReadOutputSchema,
         annotations: closedRead,
-    }, mcpTool(async (input) => {
+        action: "fs.read",
+    }, async (input) => {
         const fs = await workspaces.fs(input.workspaceId);
-        return operations.run({
-            pluginId: "workspace",
-            source: "mcp",
-            action: "fs.read",
-            workspaceId: input.workspaceId,
-            input,
-        }, () => fs.read(input.path, input.maxBytes === undefined ? {} : { maxBytes: input.maxBytes }));
-    }));
-    server.registerTool("fs_write", {
+        return fs.read(input.path, input.maxBytes === undefined ? {} : { maxBytes: input.maxBytes });
+    });
+    mcp.registerTool("fs_write", {
         title: "Write file",
         description: "Atomically write a workspace-relative file.",
         inputSchema: z.object({
@@ -72,17 +63,12 @@ export function registerWorkspaceTools(server, workspaces, operations) {
         }),
         outputSchema: fileWriteOutputSchema,
         annotations: localWrite,
-    }, mcpTool(async (input) => {
+        action: "fs.write",
+    }, async (input) => {
         const fs = await workspaces.fs(input.workspaceId);
-        return operations.run({
-            pluginId: "workspace",
-            source: "mcp",
-            action: "fs.write",
-            workspaceId: input.workspaceId,
-            input,
-        }, () => fs.write(input.path, input.content));
-    }));
-    server.registerTool("fs_list", {
+        return fs.write(input.path, input.content);
+    });
+    mcp.registerTool("fs_list", {
         title: "List files",
         description: "List files under a workspace-relative directory.",
         inputSchema: z.object({
@@ -92,19 +78,14 @@ export function registerWorkspaceTools(server, workspaces, operations) {
         }),
         outputSchema: z.object({ files: z.array(fileInfoSchema) }),
         annotations: closedRead,
-    }, mcpTool(async (input) => {
+        action: "fs.list",
+    }, async (input) => {
         const fs = await workspaces.fs(input.workspaceId);
         return {
-            files: await operations.run({
-                pluginId: "workspace",
-                source: "mcp",
-                action: "fs.list",
-                workspaceId: input.workspaceId,
-                input,
-            }, () => fs.list(input.path, { recursive: input.recursive })),
+            files: await fs.list(input.path, { recursive: input.recursive }),
         };
-    }));
-    server.registerTool("fs_search", {
+    });
+    mcp.registerTool("fs_search", {
         title: "Search files",
         description: "Search text under a workspace.",
         inputSchema: z.object({
@@ -115,22 +96,17 @@ export function registerWorkspaceTools(server, workspaces, operations) {
         }),
         outputSchema: z.object({ matches: z.array(searchMatchSchema) }),
         annotations: closedRead,
-    }, mcpTool(async (input) => {
+        action: "fs.search",
+    }, async (input) => {
         const fs = await workspaces.fs(input.workspaceId);
         return {
-            matches: await operations.run({
-                pluginId: "workspace",
-                source: "mcp",
-                action: "fs.search",
-                workspaceId: input.workspaceId,
-                input,
-            }, () => fs.search(input.query, {
+            matches: await fs.search(input.query, {
                 path: input.path,
                 maxResults: input.maxResults,
-            })),
+            }),
         };
-    }));
-    server.registerTool("fs_patch", {
+    });
+    mcp.registerTool("fs_patch", {
         title: "Transactional patch",
         description: "Validate all replacements before committing a multi-file text patch.",
         inputSchema: z.object({
@@ -148,21 +124,16 @@ export function registerWorkspaceTools(server, workspaces, operations) {
         }),
         outputSchema: changeSetSchema,
         annotations: destructiveLocalMutation,
-    }, mcpTool(async (input) => {
+        action: "fs.patch",
+    }, async (input) => {
         const fs = await workspaces.fs(input.workspaceId);
-        return operations.run({
-            pluginId: "workspace",
-            source: "mcp",
-            action: "fs.patch",
-            workspaceId: input.workspaceId,
-            input,
-        }, () => fs.patch(input.replacements.map((item) => ({
+        return fs.patch(input.replacements.map((item) => ({
             path: item.path,
             oldText: item.oldText,
             newText: item.newText,
             ...(item.occurrence === undefined
                 ? {}
                 : { occurrence: item.occurrence }),
-        }))));
-    }));
+        })));
+    });
 }