@sghanavati/relay-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ghanavati
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,189 @@
+# relay-mcp
+[![npm version](https://img.shields.io/npm/v/@sghanavati/relay-mcp.svg)](https://www.npmjs.com/package/@sghanavati/relay-mcp)
+[![Node.js](https://img.shields.io/node/v/@sghanavati/relay-mcp.svg)](https://nodejs.org)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+MCP server that lets Claude Code delegate coding tasks to Codex.
+
+> **Prerequisites:** Codex CLI >= 0.39.0 must be installed (`npm install -g @openai/codex`) and authenticated (`codex login`).
+
+## Quick Start
+Add this to your Claude Code `.mcp.json`, then restart Claude Code:
+
+```json
+{
+  "mcpServers": {
+    "relay-mcp": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@sghanavati/relay-mcp"]
+    }
+  }
+}
+```
+
+## Installation
+`@sghanavati/relay-mcp` is a zero-install MCP server when launched with `npx`.
+
+- No global install of `relay-mcp` is required.
+- `npx -y @sghanavati/relay-mcp` downloads and runs the published package directly.
+- You only need to keep Codex CLI installed and authenticated locally.
+
+## Claude Code Registration
+### npx (recommended)
+Use this in your `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "relay-mcp": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@sghanavati/relay-mcp"]
+    }
+  }
+}
+```
+
+### local dev variant (from repository root)
+Use this when iterating on local source before publishing:
+
+```json
+{
+  "mcpServers": {
+    "relay-mcp": {
+      "type": "stdio",
+      "command": "node",
+      "args": ["dist/index.js"]
+    }
+  }
+}
+```
+
+### Timeout strategy (DOCS-03)
+`relay-mcp` accepts `timeout_ms` per delegate call. Use this strategy:
+
+- Keep server registration static in `.mcp.json`.
+- Set timeouts per task based on expected scope.
+- Start with `300000` (5 minutes) for medium tasks.
+- Default timeout is `600000` (10 minutes) when omitted.
+
+Example delegate call with explicit timeout:
+
+```javascript
+delegate({
+  task: "Refactor auth middleware and update tests",
+  workdir: "/path/to/repo",
+  timeout_ms: 300000
+});
+```
+
+## Claude Desktop Registration
+On macOS, edit:
+`~/Library/Application Support/Claude/claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "relay-mcp": {
+      "command": "npx",
+      "args": ["-y", "@sghanavati/relay-mcp"],
+      "env": {
+        "RELAY_CODEX_PATH": "/usr/local/bin/codex"
+      }
+    }
+  }
+}
+```
+
+Find your Codex binary path with:
+
+```bash
+which codex
+```
+
+Claude Desktop does not inherit your shell `PATH` reliably, so `RELAY_CODEX_PATH` should be set explicitly.
+
+## Usage
+In Claude Code, ask for a delegated action, for example:
+
+```text
+Use the delegate tool to add a README to /path/to/my-project
+```
+
+Claude Code will issue a tool call like:
+
+```javascript
+delegate({
+  task: "Add a README.md with setup instructions",
+  workdir: "/path/to/my-project"
+});
+```
+
+Typical response payload:
+
+```json
+{
+  "status": "success",
+  "output": "...",
+  "files_changed": ["README.md"],
+  "meta": {
+    "duration_ms": 45000,
+    "truncated": false,
+    "warnings": [],
+    "model": null,
+    "token_estimate": 1200,
+    "exit_code": 0
+  }
+}
+```
+
+## Configuration
+| Variable | Default | Description |
+| --- | --- | --- |
+| `RELAY_CODEX_PATH` | `codex` from `PATH` | Full path to Codex binary for PATH-limited environments (especially Claude Desktop). |
+| `RELAY_LOG_LEVEL` | `info` | Startup log verbosity control. `error` suppresses the ready banner; other values show it. |
+
+## Troubleshooting
+### 1) PATH issues (Codex not found)
+Symptom:
+`Error: Codex binary not found ...`
+
+Fix:
+
+```bash
+which codex
+```
+
+Then add that path to `RELAY_CODEX_PATH` in your MCP server config `env` block.
+
+### 2) Auth failures
+Symptom:
+`Error: Codex not authenticated`
+
+Fix:
+
+```bash
+codex login
+```
+
+Then restart Claude Code or Claude Desktop.
+
+### 3) Network/DNS failures
+Symptom:
+`status: "error"` with `error.code: "CODEX_ERROR"` during delegation.
+
+Fix:
+
+- Retry the same delegate call.
+- Confirm network/DNS connectivity and any proxy requirements.
+- Re-run `codex login` if your session may have expired.
+
+## Security
+- `relay-mcp` only delegates work inside the `workdir` you pass to `delegate`.
+- `workdir` values are canonicalized with `path.resolve()` before subprocess execution (SAFE-01 / CVE-2025-59532 mitigation).
+- Codex runs with `--full-auto` and can read/write files in that delegated directory.
+- `relay-mcp` does not store credentials, API keys, or session tokens; authentication remains in Codex CLI.
+
+## License
+MIT. See [LICENSE](LICENSE).

package/dist/concurrency/index.js

@@ -0,0 +1,9 @@
+// Per-workdir mutex: prevent concurrent Codex runs in the same directory.
+import { Mutex } from "async-mutex";
+const workdirLocks = new Map();
+export function getWorkdirMutex(workdir) {
+    if (!workdirLocks.has(workdir)) {
+        workdirLocks.set(workdir, new Mutex());
+    }
+    return workdirLocks.get(workdir);
+}

package/dist/config/constants.js

@@ -0,0 +1,8 @@
+/** Default Codex delegation timeout: 10 minutes */
+export const DEFAULT_TIMEOUT_MS = 600_000;
+/** Token count at which a warning is added to meta.warnings */
+export const TOKEN_WARN_THRESHOLD = 10_000;
+/** Hard cap: output truncated at this token count */
+export const TOKEN_HARD_CAP = 25_000;
+/** Minimum supported Codex CLI version */
+export const MIN_CODEX_VERSION = [0, 39, 0];

package/dist/config/runtime.js

@@ -0,0 +1,9 @@
+const LOG_LEVELS = ["debug", "info", "warn", "error"];
+export function getCodexBin() {
+    const configuredPath = process.env.RELAY_CODEX_PATH?.trim();
+    return configuredPath ? configuredPath : "codex";
+}
+export function getRelayLogLevel() {
+    const rawLevel = (process.env.RELAY_LOG_LEVEL ?? "info").trim().toLowerCase();
+    return LOG_LEVELS.includes(rawLevel) ? rawLevel : "info";
+}

package/dist/contracts/delegate.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+const delegateSchemaShape = {
+    task: z.string().min(1).describe("The coding task to delegate to the worker"),
+    workdir: z.string().describe("Absolute path to the working directory"),
+    provider: z
+        .enum(["codex"])
+        .optional()
+        .default("codex")
+        .describe("Worker provider (currently only codex)"),
+    context: z
+        .string()
+        .optional()
+        .describe("Additional context prepended to the task before delegation"),
+    timeout_ms: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Wall-clock timeout in milliseconds (default: 600000)"),
+    model: z
+        .string()
+        .optional()
+        .describe("Model override for the provider (e.g., o4-mini for Codex)"),
+};
+const delegateArgsSchema = z.object(delegateSchemaShape);
+export const delegateSchema = delegateArgsSchema.shape;

package/dist/errors.js

@@ -0,0 +1,8 @@
+// All failure modes return RelayError - never plain strings (RELY-01)
+/**
+ * Factory for structured errors. The `retryable` flag guides CC on whether
+ * to re-invoke the delegate tool automatically.
+ */
+export function makeError(code, message, retryable) {
+    return { code, message, retryable };
+}

package/dist/git/snapshot.js

@@ -0,0 +1,41 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export async function takeSnapshot(workdir) {
+    try {
+        const { stdout } = await execFileAsync("git", ["status", "--porcelain=v1"], {
+            cwd: workdir,
+        });
+        const snapshot = new Map();
+        for (const line of stdout.split("\n")) {
+            if (!line.trim())
+                continue;
+            const statusCode = line.slice(0, 2);
+            const filepath = line.slice(3).trim();
+            snapshot.set(filepath, statusCode);
+        }
+        return snapshot;
+    }
+    catch {
+        return null;
+    }
+}
+export function diffSnapshots(pre, post) {
+    if (!post)
+        return [];
+    const changed = [];
+    for (const [filepath, postCode] of post) {
+        const preCode = pre?.get(filepath);
+        if (preCode !== postCode) {
+            changed.push(filepath);
+        }
+    }
+    if (pre) {
+        for (const [filepath] of pre) {
+            if (!post.has(filepath)) {
+                changed.push(filepath);
+            }
+        }
+    }
+    return [...new Set(changed)];
+}

package/dist/index.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { startServer } from "./server.js";
+import { cleanupAll } from "./workers/process.js";
+const HELP_TEXT = `relay-mcp
+
+MCP server that lets Claude Code delegate coding tasks to Codex.
+
+Usage:
+  relay-mcp
+  relay-mcp --help
+  relay-mcp --version
+
+Environment:
+  RELAY_CODEX_PATH  Path to Codex CLI binary (default: codex from PATH)
+  RELAY_LOG_LEVEL   Log verbosity: debug | info | warn | error (default: info)
+`;
+function getPackageVersion() {
+    try {
+        const currentFile = fileURLToPath(import.meta.url);
+        const currentDir = dirname(currentFile);
+        const packageJsonPath = resolve(currentDir, "../package.json");
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
+            return packageJson.version;
+        }
+    }
+    catch {
+        // Fall through to a safe fallback version string.
+    }
+    return "0.0.0";
+}
+function handleCliFlags(args) {
+    if (args.includes("--help") || args.includes("-h")) {
+        process.stdout.write(HELP_TEXT);
+        return true;
+    }
+    if (args.includes("--version") || args.includes("-v")) {
+        process.stdout.write(`${getPackageVersion()}\n`);
+        return true;
+    }
+    return false;
+}
+process.on("exit", () => {
+    cleanupAll();
+});
+process.on("SIGTERM", () => {
+    process.exit(0);
+});
+if (!handleCliFlags(process.argv.slice(2))) {
+    startServer().catch((err) => {
+        process.stderr.write(`relay-mcp fatal: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exit(1);
+    });
+}

package/dist/server.js

@@ -0,0 +1,15 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { delegateSchema } from "./contracts/delegate.js";
+import { validateStartup } from "./startup.js";
+import { handleDelegate } from "./tools/delegate.js";
+export async function startServer() {
+    await validateStartup();
+    const server = new McpServer({
+        name: "relay-mcp",
+        version: "1.0.0",
+    });
+    server.tool("delegate", delegateSchema, async (args) => handleDelegate(args));
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/dist/startup.js

@@ -0,0 +1,52 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { MIN_CODEX_VERSION } from "./config/constants.js";
+import { getCodexBin, getRelayLogLevel } from "./config/runtime.js";
+const execFileAsync = promisify(execFile);
+function shouldPrintReadyBanner() {
+    return getRelayLogLevel() !== "error";
+}
+function isVersionBelow(version, min) {
+    const match = version.match(/(\d+)\.(\d+)\.(\d+)/);
+    if (!match)
+        return true;
+    const [, maj, min_, pat] = match.map(Number);
+    if (maj !== min[0])
+        return maj < min[0];
+    if (min_ !== min[1])
+        return min_ < min[1];
+    return pat < min[2];
+}
+export async function validateStartup() {
+    const failures = [];
+    let codexVersion = "";
+    const codexBin = getCodexBin();
+    const configuredPath = process.env.RELAY_CODEX_PATH?.trim();
+    try {
+        const { stdout } = await execFileAsync(codexBin, ["--version"]);
+        codexVersion = stdout.trim();
+    }
+    catch {
+        const binaryHint = configuredPath
+            ? `RELAY_CODEX_PATH=${configuredPath}`
+            : "PATH (default `codex` binary)";
+        failures.push(`Error: Codex binary not found via ${binaryHint}.
+Fix: run \`npm install -g @openai/codex\` or set \`RELAY_CODEX_PATH=/full/path/to/codex\` in your MCP config, then restart relay-mcp.`);
+    }
+    if (codexVersion && isVersionBelow(codexVersion, MIN_CODEX_VERSION)) {
+        failures.push(`Error: Codex version ${codexVersion} is below minimum 0.39.0.\nFix: run \`npm install -g @openai/codex@latest\` then restart relay-mcp.`);
+    }
+    try {
+        await execFileAsync(codexBin, ["login", "status"]);
+    }
+    catch {
+        failures.push("Error: Codex not authenticated.\nFix: run `codex login` then restart relay-mcp.");
+    }
+    if (failures.length > 0) {
+        process.stderr.write(failures.join("\n\n") + "\n");
+        process.exit(1);
+    }
+    if (shouldPrintReadyBanner()) {
+        process.stderr.write(`relay-mcp ready\n  codex: ${codexVersion} ✓\n  auth: authenticated ✓\n  listening on stdio...\n`);
+    }
+}

package/dist/tools/delegate.js

@@ -0,0 +1,107 @@
+import * as path from "node:path";
+import { DEFAULT_TIMEOUT_MS, TOKEN_HARD_CAP, TOKEN_WARN_THRESHOLD } from "../config/constants.js";
+import { makeError } from "../errors.js";
+import { getWorkdirMutex } from "../concurrency/index.js";
+import { diffSnapshots, takeSnapshot } from "../git/snapshot.js";
+import { runCodexWorker } from "../workers/codex.js";
+/** Canonical workdir normalization - used by mutex key, snapshot, and worker. */
+function normalizeWorkdir(rawWorkdir) {
+    return path.resolve(rawWorkdir);
+}
+function buildDelegateMeta(params) {
+    return {
+        duration_ms: params.duration_ms,
+        truncated: params.truncated,
+        warnings: params.warnings,
+        model: params.model ?? null,
+        token_estimate: params.token_estimate,
+        exit_code: params.exit_code,
+    };
+}
+function toMcpResult(response) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(response) }],
+        isError: response.status !== "success",
+    };
+}
+export function applyTruncation(output, warnings) {
+    const tokenEstimate = Math.ceil(output.length / 4);
+    if (tokenEstimate >= TOKEN_WARN_THRESHOLD && tokenEstimate < TOKEN_HARD_CAP) {
+        warnings.push(`Output is ${tokenEstimate} tokens - approaching 25,000-token limit`);
+    }
+    if (tokenEstimate >= TOKEN_HARD_CAP) {
+        const charCap = TOKEN_HARD_CAP * 4;
+        return {
+            output: output.slice(0, charCap) + "\n\n[OUTPUT TRUNCATED]",
+            truncated: true,
+            tokenEstimate,
+        };
+    }
+    return {
+        output,
+        truncated: false,
+        tokenEstimate,
+    };
+}
+export async function handleDelegate(args) {
+    const { task, workdir: rawWorkdir, context, timeout_ms, model } = args;
+    const workdir = normalizeWorkdir(rawWorkdir);
+    const finalTask = context ? `${context}\n\n${task}` : task;
+    const preSnapshot = await takeSnapshot(workdir);
+    const release = await getWorkdirMutex(workdir).acquire();
+    let workerResult;
+    try {
+        const workerTask = {
+            task: finalTask,
+            workdir,
+            timeout_ms: timeout_ms ?? DEFAULT_TIMEOUT_MS,
+            model,
+        };
+        workerResult = await runCodexWorker(workerTask);
+    }
+    catch (err) {
+        const response = {
+            status: "error",
+            output: "",
+            files_changed: [],
+            meta: buildDelegateMeta({
+                duration_ms: 0,
+                truncated: false,
+                warnings: [],
+                model,
+                token_estimate: 0,
+                exit_code: null,
+            }),
+            error: makeError("UNKNOWN", `Unexpected worker error: ${String(err)}`, false),
+        };
+        return toMcpResult(response);
+    }
+    finally {
+        release();
+    }
+    const postSnapshot = await takeSnapshot(workdir);
+    const filesChanged = diffSnapshots(preSnapshot, postSnapshot);
+    const warnings = [];
+    if (preSnapshot === null) {
+        warnings.push("workdir is not a git repository - files_changed tracking unavailable");
+    }
+    else if (filesChanged.length === 0 && workerResult.status === "success") {
+        warnings.push("No files were modified by Codex");
+    }
+    const { output, truncated, tokenEstimate } = applyTruncation(workerResult.output, warnings);
+    const response = {
+        status: workerResult.status,
+        output,
+        files_changed: filesChanged,
+        meta: buildDelegateMeta({
+            duration_ms: workerResult.duration_ms,
+            truncated,
+            warnings,
+            model,
+            token_estimate: tokenEstimate,
+            exit_code: workerResult.exit_code,
+        }),
+        ...(workerResult.error ? { error: workerResult.error } : {}),
+    };
+    return toMcpResult(response);
+}

package/dist/workers/codex.js

@@ -0,0 +1,125 @@
+import { spawn } from "node:child_process";
+import { registerPid, unregisterPid } from "./process.js";
+import { getCodexBin } from "../config/runtime.js";
+import { makeError } from "../errors.js";
+/** Pure function for JSONL parsing - exported for testing */
+export function parseCodexLine(line) {
+    try {
+        const event = JSON.parse(line);
+        if (event["type"] === "item.completed" &&
+            typeof event["item"] === "object" &&
+            event["item"] !== null) {
+            const item = event["item"];
+            if (item["type"] === "agent_message" && typeof item["text"] === "string") {
+                return item["text"];
+            }
+        }
+    }
+    catch {
+        // Ignore malformed JSON lines.
+    }
+    return null;
+}
+export async function runCodexWorker(task) {
+    const startTime = Date.now();
+    const codexBin = getCodexBin();
+    const args = ["exec", "--cd", task.workdir, "--json", "--full-auto"];
+    if (task.model)
+        args.push("--model", task.model);
+    args.push(task.task);
+    const child = spawn(codexBin, args, {
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env },
+    });
+    child.stdin?.end();
+    if (child.pid !== undefined) {
+        registerPid(child.pid);
+    }
+    const agentMessages = [];
+    let stdoutBuf = "";
+    child.stdout?.on("data", (chunk) => {
+        stdoutBuf += chunk.toString("utf8");
+        const lines = stdoutBuf.split("\n");
+        stdoutBuf = lines.pop() ?? "";
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            const message = parseCodexLine(line);
+            if (message) {
+                agentMessages.push(message);
+            }
+        }
+    });
+    child.stderr?.on("data", (chunk) => {
+        process.stderr.write(chunk);
+    });
+    let timedOut = false;
+    const timeoutHandle = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGTERM");
+        setTimeout(() => {
+            try {
+                child.kill("SIGKILL");
+            }
+            catch {
+                // Process already exited.
+            }
+        }, 5_000);
+    }, task.timeout_ms);
+    return new Promise((resolve) => {
+        child.on("close", (code) => {
+            clearTimeout(timeoutHandle);
+            if (child.pid !== undefined) {
+                unregisterPid(child.pid);
+            }
+            if (stdoutBuf.trim()) {
+                const message = parseCodexLine(stdoutBuf);
+                if (message) {
+                    agentMessages.push(message);
+                }
+            }
+            const duration_ms = Date.now() - startTime;
+            const output = agentMessages.join("\n");
+            if (timedOut) {
+                resolve({
+                    status: "timeout",
+                    output,
+                    duration_ms,
+                    exit_code: code,
+                    error: makeError("TIMEOUT", `Codex timed out after ${task.timeout_ms}ms`, true),
+                });
+                return;
+            }
+            if (code !== 0) {
+                resolve({
+                    status: "error",
+                    output,
+                    duration_ms,
+                    exit_code: code,
+                    error: makeError("CODEX_ERROR", `Codex exited with code ${code}`, false),
+                });
+                return;
+            }
+            resolve({
+                status: "success",
+                output,
+                duration_ms,
+                exit_code: code,
+            });
+        });
+        child.on("error", (err) => {
+            clearTimeout(timeoutHandle);
+            if (child.pid !== undefined) {
+                unregisterPid(child.pid);
+            }
+            const duration_ms = Date.now() - startTime;
+            resolve({
+                status: "error",
+                output: "",
+                duration_ms,
+                exit_code: null,
+                error: makeError("BINARY_NOT_FOUND", `Failed to spawn codex binary (${codexBin}): ${err.message}. Set RELAY_CODEX_PATH=/full/path/to/codex if needed.`, false),
+            });
+        });
+    });
+}

package/dist/workers/process.js

@@ -0,0 +1,18 @@
+const pidRegistry = new Set();
+export function registerPid(pid) {
+    pidRegistry.add(pid);
+}
+export function unregisterPid(pid) {
+    pidRegistry.delete(pid);
+}
+/** Kill all registered PIDs with SIGTERM. Called on process exit. */
+export function cleanupAll() {
+    for (const pid of pidRegistry) {
+        try {
+            process.kill(pid, "SIGTERM");
+        }
+        catch {
+            // Already terminated.
+        }
+    }
+}

package/dist/workers/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@sghanavati/relay-mcp",
+  "version": "0.1.0",
+  "description": "MCP server that lets Claude Code delegate coding tasks to Codex",
+  "type": "module",
+  "bin": {
+    "relay-mcp": "dist/index.js"
+  },
+  "engines": {
+    "node": ">=18.19.0"
+  },
+  "files": [
+    "dist/",
+    "LICENSE",
+    "!dist/**/*.test.js"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm test",
+    "test": "npm run build && node --test dist/**/*.test.js",
+    "test:git": "npm run build && node dist/git/snapshot.test.js",
+    "test:codex": "npm run build && node dist/workers/codex.test.js",
+    "test:delegate": "npm run build && node dist/tools/delegate.test.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.20.2",
+    "zod": "^3.25.0",
+    "execa": "^9.6.0",
+    "async-mutex": "^0.5.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^22.0.0"
+  }
+}