@waishnav/devspace 1.0.2 → 1.0.3

package/dist/server.js

@@ -12,10 +12,12 @@ import { checkResourceAllowed, resourceUrlFromServerUrl } from "@modelcontextpro
 import { registerAppResource, registerAppTool, RESOURCE_MIME_TYPE, } from "@modelcontextprotocol/ext-apps/server";
 import express from "express";
 import * as z from "zod/v4";
+import { applyPatch } from "./apply-patch.js";
 import { loadConfig } from "./config.js";
 import { logEvent, requestIp, requestPath, commandPreview, sessionIdPrefix, } from "./logger.js";
 import { editFileTool, findFilesTool, grepFilesTool, listDirectoryTool, readFileTool, runShellTool, writeFileTool, } from "./pi-tools.js";
 import { SingleUserOAuthProvider } from "./oauth-provider.js";
+import { ProcessSessionManager } from "./process-sessions.js";
 import { createReviewCheckpointManager } from "./review-checkpoints.js";
 import { formatPathForPrompt } from "./skills.js";
 import { createWorkspaceStore } from "./workspace-store.js";
@@ -63,7 +65,7 @@ function toolWidgetDescriptorMeta(config, kind) {
     };
 }
 function toolNamesFor(config) {
-    return config.toolNaming === "short"
+    return config.toolNaming === "short" || config.toolMode === "codex"
         ? {
             openWorkspace: "open_workspace",
             read: "read",
@@ -86,7 +88,10 @@ function toolNamesFor(config) {
         };
 }
 function serverInstructions(config, toolNames) {
-    const inspection = config.minimalTools
+    if (config.toolMode === "codex") {
+        return `Use DevSpace as a local coding workspace. Call ${toolNames.openWorkspace} once per project folder or worktree and reuse its workspaceId. Use ${toolNames.read} for direct file reads, apply_patch for all file modifications, exec_command for inspection, tests, builds, and other commands, and write_stdin to poll or interact with running processes. Follow instructions returned by ${toolNames.openWorkspace}; read applicable instruction and skill files before working in their scope.`;
+    }
+    const inspection = config.toolMode !== "full"
         ? `In minimal tool mode, ${toolNames.grep}, ${toolNames.glob}, and ${toolNames.ls} are disabled; use ${toolNames.shell} with command-line tools such as grep, rg, find, ls, and tree for search and directory inspection. `
         : `Prefer ${toolNames.read}, ${toolNames.grep}, ${toolNames.glob}, and ${toolNames.ls} for file inspection. `;
     const skills = config.skillsEnabled
@@ -292,7 +297,170 @@ async function assertWorkspaceAppAssets() {
         await access(candidate);
     }
 }
-function createMcpServer(config, workspaces, reviewCheckpoints) {
+function processResult(snapshot) {
+    const status = snapshot.running
+        ? `Process running with session ID ${snapshot.sessionId}.`
+        : snapshot.signal
+            ? `Process exited after signal ${snapshot.signal}.`
+            : `Process exited with code ${snapshot.exitCode ?? "unknown"}.`;
+    return snapshot.output ? `${snapshot.output.replace(/\n$/, "")}\n${status}` : status;
+}
+function processOutputSchema() {
+    return resultOutputSchema({
+        sessionId: z.number().optional(),
+        running: z.boolean(),
+        exitCode: z.number().int().optional(),
+        signal: z.string().optional(),
+        wallTimeMs: z.number().nonnegative(),
+        outputTruncated: z.boolean(),
+    });
+}
+function processToolResponse(tool, workspaceId, snapshot, summary) {
+    const result = processResult(snapshot);
+    const content = [textBlock(result)];
+    const outputSummary = textSummary(snapshot.output ? [textBlock(snapshot.output)] : []);
+    return {
+        content,
+        _meta: {
+            tool,
+            card: {
+                workspaceId,
+                summary: { ...summary, ...outputSummary },
+                payload: { content },
+            },
+        },
+        structuredContent: {
+            result,
+            sessionId: snapshot.sessionId,
+            running: snapshot.running,
+            exitCode: snapshot.exitCode,
+            signal: snapshot.signal,
+            wallTimeMs: snapshot.wallTimeMs,
+            outputTruncated: snapshot.outputTruncated,
+        },
+    };
+}
+function registerCodexProcessTools(server, config, workspaces, processSessions) {
+    registerAppTool(server, "exec_command", {
+        title: "Execute command",
+        description: "Run a command inside an open workspace. Returns its result when it exits during the yield window, otherwise returns a sessionId for write_stdin. Use this for file inspection, tests, builds, package scripts, and long-running processes. Call open_workspace first and pass workspaceId.",
+        inputSchema: {
+            workspaceId: z.string().describe("Workspace identifier returned by open_workspace."),
+            cmd: z.string().min(1).describe("Shell command to execute."),
+            tty: z
+                .boolean()
+                .optional()
+                .describe("Allocate a pseudo-terminal for interactive commands. Defaults to false."),
+            columns: z.number().int().min(1).max(1_000).optional().describe("Initial PTY width. Defaults to 80."),
+            rows: z.number().int().min(1).max(1_000).optional().describe("Initial PTY height. Defaults to 24."),
+            workingDirectory: z
+                .string()
+                .optional()
+                .describe("Working directory relative to the workspace root. Defaults to the workspace root."),
+            yieldTimeMs: z
+                .number()
+                .int()
+                .min(0)
+                .max(30_000)
+                .optional()
+                .describe("Milliseconds to wait before returning a running session. Defaults to 10000."),
+            maxOutputTokens: z
+                .number()
+                .int()
+                .positive()
+                .max(100_000)
+                .optional()
+                .describe("Approximate output token budget. Defaults to 10000."),
+        },
+        outputSchema: processOutputSchema(),
+        ...toolWidgetDescriptorMeta(config, "shell"),
+        annotations: SHELL_TOOL_ANNOTATIONS,
+    }, async ({ workspaceId, cmd, tty, columns, rows, workingDirectory, yieldTimeMs, maxOutputTokens }) => {
+        const startedAt = performance.now();
+        const workspace = workspaces.getWorkspace(workspaceId);
+        const cwd = workspaces.resolveWorkingDirectory(workspace, workingDirectory);
+        const snapshot = await processSessions.start({
+            workspaceId,
+            command: cmd,
+            cwd,
+            tty,
+            columns,
+            rows,
+            yieldTimeMs,
+            maxOutputTokens,
+        });
+        logToolCall(config, {
+            tool: "exec_command",
+            workspaceId,
+            workingDirectory: workingDirectory ?? ".",
+            command: cmd,
+            commandLength: cmd.length,
+            success: true,
+            durationMs: Math.round(performance.now() - startedAt),
+        });
+        return processToolResponse("exec_command", workspaceId, snapshot, {
+            command: cmd,
+            workingDirectory: workingDirectory ?? ".",
+            running: snapshot.running,
+            exitCode: snapshot.exitCode,
+            wallTimeMs: snapshot.wallTimeMs,
+        });
+    });
+    registerAppTool(server, "write_stdin", {
+        title: "Write to process",
+        description: "Poll or write characters to a process returned by exec_command. Omit chars or pass an empty string to poll. Pass \\u0003 to send Ctrl-C.",
+        inputSchema: {
+            workspaceId: z.string().describe("Workspace identifier used to start the process."),
+            sessionId: z.number().describe("Process session identifier returned by exec_command."),
+            chars: z.string().optional().describe("Characters to write. Omit or pass an empty string to poll."),
+            columns: z.number().int().min(1).max(1_000).optional().describe("Resize a PTY to this width."),
+            rows: z.number().int().min(1).max(1_000).optional().describe("Resize a PTY to this height."),
+            yieldTimeMs: z
+                .number()
+                .int()
+                .min(0)
+                .max(30_000)
+                .optional()
+                .describe("Milliseconds to wait for process output or completion. Defaults to 10000."),
+            maxOutputTokens: z
+                .number()
+                .int()
+                .positive()
+                .max(100_000)
+                .optional()
+                .describe("Approximate output token budget. Defaults to 10000."),
+        },
+        outputSchema: processOutputSchema(),
+        ...toolWidgetDescriptorMeta(config, "shell"),
+        annotations: SHELL_TOOL_ANNOTATIONS,
+    }, async ({ workspaceId, sessionId, chars, columns, rows, yieldTimeMs, maxOutputTokens }) => {
+        const startedAt = performance.now();
+        workspaces.getWorkspace(workspaceId);
+        const snapshot = await processSessions.write({
+            workspaceId,
+            sessionId,
+            chars,
+            columns,
+            rows,
+            yieldTimeMs,
+            maxOutputTokens,
+        });
+        logToolCall(config, {
+            tool: "write_stdin",
+            workspaceId,
+            success: true,
+            durationMs: Math.round(performance.now() - startedAt),
+        });
+        return processToolResponse("write_stdin", workspaceId, snapshot, {
+            sessionId,
+            charactersWritten: chars?.length ?? 0,
+            running: snapshot.running,
+            exitCode: snapshot.exitCode,
+            wallTimeMs: snapshot.wallTimeMs,
+        });
+    });
+}
+function createMcpServer(config, workspaces, reviewCheckpoints, processSessions) {
     const toolNames = toolNamesFor(config);
     const server = new McpServer({
         name: "devspace",
@@ -530,144 +698,209 @@ function createMcpServer(config, workspaces, reviewCheckpoints) {
             },
         };
     });
-    registerAppTool(server, toolNames.write, {
-        title: "Write file",
-        description: `Create or completely overwrite a file inside an open workspace. Prefer ${toolNames.edit} for targeted changes to existing files. Call open_workspace first and pass workspaceId.`,
-        inputSchema: {
-            workspaceId: z
-                .string()
-                .describe("Workspace identifier returned by open_workspace."),
-            path: z
-                .string()
-                .describe("File path to write, relative to the workspace root."),
-            content: z.string().describe("Complete new file content."),
-        },
-        outputSchema: resultOutputSchema(),
-        ...toolWidgetDescriptorMeta(config, "write"),
-        annotations: WRITE_TOOL_ANNOTATIONS,
-    }, async ({ workspaceId, ...input }) => {
-        const startedAt = performance.now();
-        const workspace = workspaces.getWorkspace(workspaceId);
-        workspaces.resolvePath(workspace, input.path);
-        const response = await writeFileTool(input, {
-            cwd: workspace.root,
-            root: workspace.root,
-        });
-        if (response.isError) {
-            logFailedToolResponse(config, {
+    if (config.toolMode !== "codex") {
+        registerAppTool(server, toolNames.write, {
+            title: "Write file",
+            description: `Create or completely overwrite a file inside an open workspace. Prefer ${toolNames.edit} for targeted changes to existing files. Call open_workspace first and pass workspaceId.`,
+            inputSchema: {
+                workspaceId: z
+                    .string()
+                    .describe("Workspace identifier returned by open_workspace."),
+                path: z
+                    .string()
+                    .describe("File path to write, relative to the workspace root."),
+                content: z.string().describe("Complete new file content."),
+            },
+            outputSchema: resultOutputSchema(),
+            ...toolWidgetDescriptorMeta(config, "write"),
+            annotations: WRITE_TOOL_ANNOTATIONS,
+        }, async ({ workspaceId, ...input }) => {
+            const startedAt = performance.now();
+            const workspace = workspaces.getWorkspace(workspaceId);
+            workspaces.resolvePath(workspace, input.path);
+            const response = await writeFileTool(input, {
+                cwd: workspace.root,
+                root: workspace.root,
+            });
+            if (response.isError) {
+                logFailedToolResponse(config, {
+                    tool: toolNames.write,
+                    workspaceId,
+                    path: input.path,
+                }, response.content, startedAt);
+                return response;
+            }
+            const patch = newFilePatch(input.path, input.content);
+            const stats = countDiffStats(patch);
+            const summary = {
+                ...stats,
+                lines: contentLineCount(input.content),
+                characters: input.content.length,
+            };
+            logToolCall(config, {
                 tool: toolNames.write,
                 workspaceId,
                 path: input.path,
-            }, response.content, startedAt);
-            return response;
-        }
-        const patch = newFilePatch(input.path, input.content);
-        const stats = countDiffStats(patch);
-        const summary = {
-            ...stats,
-            lines: contentLineCount(input.content),
-            characters: input.content.length,
-        };
-        logToolCall(config, {
-            tool: toolNames.write,
-            workspaceId,
-            path: input.path,
-            success: true,
-            durationMs: Math.round(performance.now() - startedAt),
-        });
-        return {
-            ...response,
-            _meta: {
-                tool: toolNames.write,
-                card: {
-                    workspaceId,
-                    path: input.path,
-                    summary,
-                    payload: {
-                        content: response.content,
-                        patch,
+                success: true,
+                durationMs: Math.round(performance.now() - startedAt),
+            });
+            return {
+                ...response,
+                _meta: {
+                    tool: toolNames.write,
+                    card: {
+                        workspaceId,
+                        path: input.path,
+                        summary,
+                        payload: {
+                            content: response.content,
+                            patch,
+                        },
                     },
                 },
-            },
-            structuredContent: {
-                result: contentText(response.content),
-            },
-        };
-    });
-    registerAppTool(server, toolNames.edit, {
-        title: "Edit file",
-        description: `Edit one file inside an open workspace by replacing exact text blocks. Prefer this over ${toolNames.write} for targeted changes. Each oldText must match a unique, non-overlapping region of the original file; merge nearby changes into one edit and keep oldText as small as possible while still unique. Call open_workspace first and pass workspaceId.`,
-        inputSchema: {
-            workspaceId: z
-                .string()
-                .describe("Workspace identifier returned by open_workspace."),
-            path: z
-                .string()
-                .describe("File path to edit, relative to the workspace root."),
-            edits: z
-                .array(z.object({
-                oldText: z
-                    .string()
-                    .describe("Exact text to replace. Must match uniquely in the original file."),
-                newText: z.string().describe("Replacement text."),
-            }))
-                .min(1),
-        },
-        outputSchema: resultOutputSchema({
-            status: z.literal("applied"),
-        }),
-        ...toolWidgetDescriptorMeta(config, "edit"),
-        annotations: EDIT_TOOL_ANNOTATIONS,
-    }, async ({ workspaceId, ...input }) => {
-        const startedAt = performance.now();
-        const workspace = workspaces.getWorkspace(workspaceId);
-        workspaces.resolvePath(workspace, input.path);
-        const response = await editFileTool(input, {
-            cwd: workspace.root,
-            root: workspace.root,
+                structuredContent: {
+                    result: contentText(response.content),
+                },
+            };
         });
-        if (response.isError) {
-            logFailedToolResponse(config, {
+        registerAppTool(server, toolNames.edit, {
+            title: "Edit file",
+            description: `Edit one file inside an open workspace by replacing exact text blocks. Prefer this over ${toolNames.write} for targeted changes. Each oldText must match a unique, non-overlapping region of the original file; merge nearby changes into one edit and keep oldText as small as possible while still unique. Call open_workspace first and pass workspaceId.`,
+            inputSchema: {
+                workspaceId: z
+                    .string()
+                    .describe("Workspace identifier returned by open_workspace."),
+                path: z
+                    .string()
+                    .describe("File path to edit, relative to the workspace root."),
+                edits: z
+                    .array(z.object({
+                    oldText: z
+                        .string()
+                        .describe("Exact text to replace. Must match uniquely in the original file."),
+                    newText: z.string().describe("Replacement text."),
+                }))
+                    .min(1),
+            },
+            outputSchema: resultOutputSchema({
+                status: z.literal("applied"),
+            }),
+            ...toolWidgetDescriptorMeta(config, "edit"),
+            annotations: EDIT_TOOL_ANNOTATIONS,
+        }, async ({ workspaceId, ...input }) => {
+            const startedAt = performance.now();
+            const workspace = workspaces.getWorkspace(workspaceId);
+            workspaces.resolvePath(workspace, input.path);
+            const response = await editFileTool(input, {
+                cwd: workspace.root,
+                root: workspace.root,
+            });
+            if (response.isError) {
+                logFailedToolResponse(config, {
+                    tool: toolNames.edit,
+                    workspaceId,
+                    path: input.path,
+                }, response.content, startedAt);
+                return response;
+            }
+            const stats = countDiffStats(response.details?.patch ?? response.details?.diff);
+            const summary = {
+                ...stats,
+                editCount: input.edits.length,
+            };
+            const editResultText = `Edited ${input.path} (+${stats.additions} -${stats.removals}).`;
+            const editContent = [textBlock(editResultText)];
+            logToolCall(config, {
                 tool: toolNames.edit,
                 workspaceId,
                 path: input.path,
-            }, response.content, startedAt);
-            return response;
-        }
-        const stats = countDiffStats(response.details?.patch ?? response.details?.diff);
-        const summary = {
-            ...stats,
-            editCount: input.edits.length,
-        };
-        const editResultText = `Edited ${input.path} (+${stats.additions} -${stats.removals}).`;
-        const editContent = [textBlock(editResultText)];
-        logToolCall(config, {
-            tool: toolNames.edit,
-            workspaceId,
-            path: input.path,
-            success: true,
-            durationMs: Math.round(performance.now() - startedAt),
-        });
-        return {
-            content: editContent,
-            _meta: {
-                tool: toolNames.edit,
-                card: {
-                    workspaceId,
-                    path: input.path,
-                    summary,
-                    payload: {
-                        diff: response.details?.diff,
-                        patch: response.details?.patch,
+                success: true,
+                durationMs: Math.round(performance.now() - startedAt),
+            });
+            return {
+                content: editContent,
+                _meta: {
+                    tool: toolNames.edit,
+                    card: {
+                        workspaceId,
+                        path: input.path,
+                        summary,
+                        payload: {
+                            diff: response.details?.diff,
+                            patch: response.details?.patch,
+                        },
                     },
                 },
+                structuredContent: {
+                    status: "applied",
+                    result: contentText(editContent),
+                },
+            };
+        });
+    }
+    if (config.toolMode === "codex") {
+        registerAppTool(server, "apply_patch", {
+            title: "Apply patch",
+            description: "Apply one Codex-style patch inside an open workspace. Supports adding, overwriting, updating, deleting, and moving files. Earlier successful file changes remain if a later patch action fails. Use this for all file modifications. Paths must be relative to the workspace. Call open_workspace first and pass workspaceId.",
+            inputSchema: {
+                workspaceId: z
+                    .string()
+                    .describe("Workspace identifier returned by open_workspace."),
+                patch: z
+                    .string()
+                    .describe("Patch text enclosed by *** Begin Patch and *** End Patch markers."),
             },
-            structuredContent: {
-                status: "applied",
-                result: contentText(editContent),
-            },
-        };
-    });
+            outputSchema: resultOutputSchema({
+                additions: z.number(),
+                removals: z.number(),
+                files: z.array(z.object({
+                    path: z.string(),
+                    previousPath: z.string().optional(),
+                    operation: z.enum(["add", "update", "delete", "move"]),
+                })),
+            }),
+            ...toolWidgetDescriptorMeta(config, "edit"),
+            annotations: EDIT_TOOL_ANNOTATIONS,
+        }, async ({ workspaceId, patch }) => {
+            const startedAt = performance.now();
+            const workspace = workspaces.getWorkspace(workspaceId);
+            const applied = await applyPatch(workspace.root, patch);
+            const paths = applied.files.map((file) => file.path).join(", ");
+            const result = `Applied patch to ${applied.files.length} file(s): ${paths}`;
+            const content = [textBlock(result)];
+            const displayPath = applied.files.length === 1
+                ? applied.files[0]?.path
+                : `${applied.files.length} files`;
+            logToolCall(config, {
+                tool: "apply_patch",
+                workspaceId,
+                success: true,
+                durationMs: Math.round(performance.now() - startedAt),
+            });
+            return {
+                content,
+                _meta: {
+                    tool: "apply_patch",
+                    card: {
+                        workspaceId,
+                        path: displayPath,
+                        summary: {
+                            files: applied.files.length,
+                            additions: applied.additions,
+                            removals: applied.removals,
+                        },
+                        payload: { patch: applied.patch },
+                    },
+                },
+                structuredContent: {
+                    result,
+                    additions: applied.additions,
+                    removals: applied.removals,
+                    files: applied.files,
+                },
+            };
+        });
+    }
     if (config.widgets === "changes") {
         registerAppTool(server, "show_changes", {
             title: "Show changes",
@@ -723,7 +956,7 @@ function createMcpServer(config, workspaces, reviewCheckpoints) {
             };
         });
     }
-    if (!config.minimalTools) {
+    if (config.toolMode === "full") {
         registerAppTool(server, toolNames.grep, {
             title: config.toolNaming === "short" ? "Grep" : "Grep files",
             description: "Search file contents inside an open workspace. Use this before broad reads when looking for symbols, text, or usage sites. Respects project ignore rules. Call open_workspace first and pass workspaceId.",
@@ -902,80 +1135,85 @@ function createMcpServer(config, workspaces, reviewCheckpoints) {
             };
         });
     }
-    registerAppTool(server, toolNames.shell, {
-        title: config.toolNaming === "short" ? "Bash" : "Run shell",
-        description: config.minimalTools
-            ? `Run a shell command inside an open workspace. Use only for tests, builds, git inspection, package scripts, search, file discovery, and directory inspection. In minimal tool mode, ${toolNames.grep}, ${toolNames.glob}, and ${toolNames.ls} are disabled; use command-line tools such as grep, rg, find, ls, and tree for those read-only inspection actions. Do not use ${toolNames.shell} to create or modify files. Do not use shell redirection, heredocs, tee, sed -i, perl -i, node/python/ruby scripts, or generated scripts to write project files; use ${toolNames.edit} for targeted changes and ${toolNames.write} for new files or full rewrites. Prefer ${toolNames.read} for direct file reads. Call open_workspace first and pass workspaceId. This is powerful local execution and should only be exposed behind strong authentication.`
-            : `Run a shell command inside an open workspace. Use only for tests, builds, git inspection, package scripts, and commands that are better executed by the shell. Do not use ${toolNames.shell} to create or modify files. Do not use shell redirection, heredocs, tee, sed -i, perl -i, node/python/ruby scripts, or generated scripts to write project files; use ${toolNames.edit} for targeted changes and ${toolNames.write} for new files or full rewrites. Prefer ${toolNames.read}, ${toolNames.grep}, ${toolNames.glob}, and ${toolNames.ls} for file inspection. Call open_workspace first and pass workspaceId. This is powerful local execution and should only be exposed behind strong authentication.`,
-        inputSchema: {
-            workspaceId: z
-                .string()
-                .describe("Workspace identifier returned by open_workspace."),
-            command: z
-                .string()
-                .describe(`Shell command to run. Must not create or modify project files; use ${toolNames.edit} or ${toolNames.write} for file changes.`),
-            workingDirectory: z
-                .string()
-                .optional()
-                .describe("Optional working directory relative to the workspace root. Defaults to the workspace root."),
-            timeout: z
-                .number()
-                .positive()
-                .max(300)
-                .optional()
-                .describe("Timeout in seconds. Defaults to 30, max 300."),
-        },
-        outputSchema: resultOutputSchema(),
-        ...toolWidgetDescriptorMeta(config, "shell"),
-        annotations: SHELL_TOOL_ANNOTATIONS,
-    }, async ({ workspaceId, workingDirectory, ...input }) => {
-        const startedAt = performance.now();
-        const workspace = workspaces.getWorkspace(workspaceId);
-        const cwd = workspaces.resolveWorkingDirectory(workspace, workingDirectory);
-        const response = await runShellTool(input, {
-            cwd,
-            root: workspace.root,
-        });
-        if (response.isError) {
-            logFailedToolResponse(config, {
+    if (config.toolMode !== "codex") {
+        registerAppTool(server, toolNames.shell, {
+            title: config.toolNaming === "short" ? "Bash" : "Run shell",
+            description: config.toolMode !== "full"
+                ? `Run a shell command inside an open workspace. Use only for tests, builds, git inspection, package scripts, search, file discovery, and directory inspection. In minimal tool mode, ${toolNames.grep}, ${toolNames.glob}, and ${toolNames.ls} are disabled; use command-line tools such as grep, rg, find, ls, and tree for those read-only inspection actions. Do not use ${toolNames.shell} to create or modify files. Do not use shell redirection, heredocs, tee, sed -i, perl -i, node/python/ruby scripts, or generated scripts to write project files; use ${toolNames.edit} for targeted changes and ${toolNames.write} for new files or full rewrites. Prefer ${toolNames.read} for direct file reads. Call open_workspace first and pass workspaceId. This is powerful local execution and should only be exposed behind strong authentication.`
+                : `Run a shell command inside an open workspace. Use only for tests, builds, git inspection, package scripts, and commands that are better executed by the shell. Do not use ${toolNames.shell} to create or modify files. Do not use shell redirection, heredocs, tee, sed -i, perl -i, node/python/ruby scripts, or generated scripts to write project files; use ${toolNames.edit} for targeted changes and ${toolNames.write} for new files or full rewrites. Prefer ${toolNames.read}, ${toolNames.grep}, ${toolNames.glob}, and ${toolNames.ls} for file inspection. Call open_workspace first and pass workspaceId. This is powerful local execution and should only be exposed behind strong authentication.`,
+            inputSchema: {
+                workspaceId: z
+                    .string()
+                    .describe("Workspace identifier returned by open_workspace."),
+                command: z
+                    .string()
+                    .describe(`Shell command to run. Must not create or modify project files; use ${toolNames.edit} or ${toolNames.write} for file changes.`),
+                workingDirectory: z
+                    .string()
+                    .optional()
+                    .describe("Optional working directory relative to the workspace root. Defaults to the workspace root."),
+                timeout: z
+                    .number()
+                    .positive()
+                    .max(300)
+                    .optional()
+                    .describe("Timeout in seconds. Defaults to 30, max 300."),
+            },
+            outputSchema: resultOutputSchema(),
+            ...toolWidgetDescriptorMeta(config, "shell"),
+            annotations: SHELL_TOOL_ANNOTATIONS,
+        }, async ({ workspaceId, workingDirectory, ...input }) => {
+            const startedAt = performance.now();
+            const workspace = workspaces.getWorkspace(workspaceId);
+            const cwd = workspaces.resolveWorkingDirectory(workspace, workingDirectory);
+            const response = await runShellTool(input, {
+                cwd,
+                root: workspace.root,
+            });
+            if (response.isError) {
+                logFailedToolResponse(config, {
+                    tool: toolNames.shell,
+                    workspaceId,
+                    workingDirectory: workingDirectory ?? ".",
+                    command: input.command,
+                    commandLength: input.command.length,
+                }, response.content, startedAt);
+                return response;
+            }
+            const summary = {
+                command: input.command,
+                workingDirectory: workingDirectory ?? ".",
+                ...textSummary(response.content),
+            };
+            logToolCall(config, {
                 tool: toolNames.shell,
                 workspaceId,
                 workingDirectory: workingDirectory ?? ".",
                 command: input.command,
                 commandLength: input.command.length,
-            }, response.content, startedAt);
-            return response;
-        }
-        const summary = {
-            command: input.command,
-            workingDirectory: workingDirectory ?? ".",
-            ...textSummary(response.content),
-        };
-        logToolCall(config, {
-            tool: toolNames.shell,
-            workspaceId,
-            workingDirectory: workingDirectory ?? ".",
-            command: input.command,
-            commandLength: input.command.length,
-            success: true,
-            durationMs: Math.round(performance.now() - startedAt),
-        });
-        return {
-            ...response,
-            _meta: {
-                tool: toolNames.shell,
-                card: {
-                    workspaceId,
-                    path: workingDirectory,
-                    summary,
-                    payload: { content: response.content },
+                success: true,
+                durationMs: Math.round(performance.now() - startedAt),
+            });
+            return {
+                ...response,
+                _meta: {
+                    tool: toolNames.shell,
+                    card: {
+                        workspaceId,
+                        path: workingDirectory,
+                        summary,
+                        payload: { content: response.content },
+                    },
                 },
-            },
-            structuredContent: {
-                result: contentText(response.content),
-            },
-        };
-    });
+                structuredContent: {
+                    result: contentText(response.content),
+                },
+            };
+        });
+    }
+    if (config.toolMode === "codex") {
+        registerCodexProcessTools(server, config, workspaces, processSessions);
+    }
     return server;
 }
 export function createServer(config = loadConfig()) {
@@ -998,6 +1236,7 @@ export function createServer(config = loadConfig()) {
     const workspaceStore = createWorkspaceStore(config.stateDir);
     const workspaces = new WorkspaceRegistry(config, workspaceStore);
     const reviewCheckpoints = createReviewCheckpointManager();
+    const processSessions = new ProcessSessionManager();
     if (config.logging.trustProxy) {
         app.set("trust proxy", true);
     }
@@ -1106,7 +1345,7 @@ export function createServer(config = loadConfig()) {
                         });
                     }
                 };
-                const server = createMcpServer(config, workspaces, reviewCheckpoints);
+                const server = createMcpServer(config, workspaces, reviewCheckpoints, processSessions);
                 await server.connect(transport);
             }
             else {
@@ -1133,6 +1372,7 @@ export function createServer(config = loadConfig()) {
             if (closed)
                 return;
             closed = true;
+            processSessions.shutdown();
             oauthProvider.close();
             workspaceStore.close?.();
         },