@dhrupo/codex-claude-bridge 0.1.0

package/README.md

@@ -0,0 +1,160 @@
+# codex-claude-bridge
+
+Use Claude Code from inside Codex.
+
+This package exposes Claude Code as MCP tools that Codex can call, and also ships a small `codex-claude` command for common flows.
+
+## What You Get
+
+- `codex-claude-mcp`: an MCP server that wraps the local `claude` CLI
+- `codex-claude`: a helper command that drives Codex to call the Claude MCP tools
+- Three MCP tools:
+  - `claude_ask`
+  - `claude_review`
+  - `claude_delegate`
+
+## Requirements
+
+- Node.js `>=18.18.0`
+- `codex` installed and authenticated
+- `claude` installed and authenticated
+
+Check both CLIs first:
+
+```bash
+codex --version
+claude --version
+claude auth status
+```
+
+## Install
+
+Install the package:
+
+```bash
+npm install -g @dhrupo/codex-claude-bridge
+```
+
+Register the MCP server in Codex:
+
+```bash
+codex-claude install
+```
+
+That adds a global Codex MCP server named `claude-bridge`.
+
+You can also register it manually:
+
+```bash
+codex mcp add claude-bridge -- codex-claude-mcp
+```
+
+Or without a global npm install:
+
+```bash
+codex mcp add claude-bridge -- npx -y @dhrupo/codex-claude-bridge
+```
+
+Confirm registration:
+
+```bash
+codex mcp list
+```
+
+## Usage
+
+### Run Through The Helper Command
+
+Ask Claude a question through Codex:
+
+```bash
+codex-claude ask "Summarize the current repository."
+```
+
+Run a review:
+
+```bash
+codex-claude review
+codex-claude review "Review the current workspace for bugs and missing tests."
+```
+
+Delegate an implementation task:
+
+```bash
+codex-claude delegate "Fix the failing tests with the smallest safe patch."
+```
+
+If you are outside a git repository, add:
+
+```bash
+--skip-git-repo-check
+```
+
+Example:
+
+```bash
+codex-claude ask --cwd /path/to/project --skip-git-repo-check "Reply with exactly OK."
+```
+
+### Run Through Codex Directly
+
+Once installed, Codex can call these tools directly:
+
+- `claude_ask`: read-only prompting
+- `claude_review`: stricter review pass
+- `claude_delegate`: writable implementation/delegation flow
+
+Example `codex exec` prompt:
+
+```bash
+codex exec --cd /path/to/project --skip-git-repo-check \
+  'Use the MCP tool `claude_ask` exactly once. Return only the tool result. Tool arguments: {"prompt":"Summarize this repo.","cwd":"/path/to/project","outputFormat":"text"}'
+```
+
+## How It Works
+
+- Codex discovers the `claude-bridge` MCP server
+- Codex calls one of the bridge tools
+- The bridge runs the local `claude --print` command
+- The Claude response is returned back through MCP to Codex
+
+This is an MCP bridge, not a native Codex slash-command plugin.
+
+## Development
+
+Install dependencies:
+
+```bash
+npm install
+```
+
+Run tests:
+
+```bash
+npm test
+```
+
+Start the MCP server directly:
+
+```bash
+npm start
+```
+
+## Troubleshooting
+
+If the bridge works but Claude returns an auth or access error, test Claude directly first:
+
+```bash
+claude -p --output-format text "Reply with exactly OK."
+```
+
+If that fails, fix Claude access before testing through Codex.
+
+If Codex is outside a git repo, use `--skip-git-repo-check`.
+
+If needed, remove and re-add the MCP server:
+
+```bash
+codex mcp remove claude-bridge
+codex mcp add claude-bridge -- codex-claude-mcp
+```

package/bin/codex-claude-mcp.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { startServer } from "../src/server.mjs";
+
+startServer().catch((error) => {
+  console.error(error instanceof Error ? error.stack || error.message : String(error));
+  process.exitCode = 1;
+});

package/bin/codex-claude.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { runCodexClaudeCli } from "../src/codex-claude-command.mjs";
+
+runCodexClaudeCli(process.argv.slice(2)).catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@dhrupo/codex-claude-bridge",
+  "version": "0.1.0",
+  "description": "Expose Claude Code as MCP tools for Codex.",
+  "type": "module",
+  "bin": {
+    "codex-claude": "./bin/codex-claude.mjs",
+    "codex-claude-mcp": "./bin/codex-claude-mcp.mjs"
+  },
+  "engines": {
+    "node": ">=18.18.0"
+  },
+  "scripts": {
+    "test": "node --test tests/*.test.mjs",
+    "start": "node ./bin/codex-claude-mcp.mjs",
+    "check": "node --test tests/*.test.mjs"
+  },
+  "keywords": [
+    "codex",
+    "claude",
+    "mcp",
+    "anthropic",
+    "openai"
+  ],
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.1.12"
+  }
+}

package/src/claude-cli.mjs

@@ -0,0 +1,102 @@
+import { spawn } from "node:child_process";
+
+function pushListOption(args, flag, values) {
+  if (!Array.isArray(values) || values.length === 0) {
+    return;
+  }
+  args.push(flag, values.join(" "));
+}
+
+export function buildClaudeArgs(input, defaults = {}) {
+  const args = ["--print"];
+  const outputFormat = input.outputFormat || defaults.outputFormat || "text";
+  const permissionMode = input.permissionMode || defaults.permissionMode;
+
+  args.push("--output-format", outputFormat);
+
+  if (input.model) {
+    args.push("--model", input.model);
+  }
+  if (permissionMode) {
+    args.push("--permission-mode", permissionMode);
+  }
+  if (typeof input.maxBudgetUsd === "number") {
+    args.push("--max-budget-usd", String(input.maxBudgetUsd));
+  }
+  if (input.appendSystemPrompt) {
+    args.push("--append-system-prompt", input.appendSystemPrompt);
+  }
+
+  pushListOption(args, "--allowedTools", input.allowedTools);
+  pushListOption(args, "--disallowedTools", input.disallowedTools);
+
+  args.push(input.prompt);
+  return args;
+}
+
+function normalizeStdout(stdout, outputFormat) {
+  if (outputFormat === "json") {
+    try {
+      return JSON.stringify(JSON.parse(stdout), null, 2);
+    } catch {
+      return stdout.trim();
+    }
+  }
+  return stdout.trim();
+}
+
+export async function runClaude(input, options = {}) {
+  const command = options.command || "claude";
+  const cwd = input.cwd || options.cwd || process.cwd();
+  const args = buildClaudeArgs(input, options.defaults);
+  const outputFormat = input.outputFormat || options.defaults?.outputFormat || "text";
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      env: {
+        ...process.env,
+        ...options.env
+      },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+
+    child.on("error", (error) => {
+      reject(
+        new Error(`Failed to start Claude CLI. Ensure \`claude\` is installed and on PATH. ${error.message}`)
+      );
+    });
+
+    child.on("close", (code) => {
+      const trimmedStdout = stdout.trim();
+      const trimmedStderr = stderr.trim();
+
+      if (code !== 0) {
+        reject(
+          new Error(trimmedStderr || trimmedStdout || `Claude CLI exited with status ${code ?? "unknown"}.`)
+        );
+        return;
+      }
+
+      resolve({
+        command,
+        cwd,
+        args,
+        outputFormat,
+        stdout: normalizeStdout(trimmedStdout, outputFormat),
+        stderr: trimmedStderr
+      });
+    });
+  });
+}

package/src/codex-claude-command.mjs

@@ -0,0 +1,145 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { DEFAULT_MCP_SERVER_NAME } from "./constants.mjs";
+import { buildCodexExecArgs, buildCodexMcpAddArgs, runCodex } from "./codex-cli.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const serverScript = path.resolve(__dirname, "../bin/codex-claude-mcp.mjs");
+
+function usage() {
+  return [
+    "Usage:",
+    "  codex-claude install [--name <server-name>]",
+    "  codex-claude ask [--cwd <dir>] [--model <model>] [--skip-git-repo-check] <prompt>",
+    "  codex-claude review [--cwd <dir>] [--model <model>] [--skip-git-repo-check] [prompt]",
+    "  codex-claude delegate [--cwd <dir>] [--model <model>] [--skip-git-repo-check] <prompt>"
+  ].join("\n");
+}
+
+function parseCommand(argv) {
+  if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+    return { command: "help" };
+  }
+
+  const [command, ...rest] = argv;
+  const options = {
+    command,
+    cwd: undefined,
+    model: undefined,
+    skipGitRepoCheck: false,
+    serverName: DEFAULT_MCP_SERVER_NAME,
+    prompt: ""
+  };
+
+  for (let index = 0; index < rest.length; index += 1) {
+    const token = rest[index];
+    if (token === "--cwd") {
+      index += 1;
+      options.cwd = rest[index];
+      continue;
+    }
+    if (token === "--model") {
+      index += 1;
+      options.model = rest[index];
+      continue;
+    }
+    if (token === "--name") {
+      index += 1;
+      options.serverName = rest[index];
+      continue;
+    }
+    if (token === "--skip-git-repo-check") {
+      options.skipGitRepoCheck = true;
+      continue;
+    }
+    options.prompt = rest.slice(index).join(" ");
+    break;
+  }
+
+  return options;
+}
+
+export function buildCodexClaudePrompt(input) {
+  const toolNameByCommand = {
+    ask: "claude_ask",
+    review: "claude_review",
+    delegate: "claude_delegate"
+  };
+
+  const toolName = toolNameByCommand[input.command];
+  const prompt =
+    input.prompt ||
+    (input.command === "review"
+      ? "Review the current repository for bugs, regressions, and missing tests."
+      : "");
+
+  if (!toolName || !prompt) {
+    throw new Error(usage());
+  }
+
+  const call = {
+    prompt,
+    cwd: input.cwd || process.cwd(),
+    outputFormat: "text"
+  };
+
+  return [
+    `Use the MCP tool \`${toolName}\` exactly once.`,
+    "Do not solve this task yourself.",
+    "Return only the tool result with no extra framing.",
+    "",
+    `Tool arguments: ${JSON.stringify(call)}`
+  ].join("\n");
+}
+
+async function installBridge(input) {
+  const args = buildCodexMcpAddArgs({
+    serverName: input.serverName,
+    serverScript
+  });
+
+  return runCodex(args, {
+    cwd: input.cwd || process.cwd()
+  });
+}
+
+async function runViaCodex(input) {
+  const args = buildCodexExecArgs({
+    cwd: input.cwd,
+    model: input.model,
+    skipGitRepoCheck: input.skipGitRepoCheck,
+    prompt: buildCodexClaudePrompt(input)
+  });
+
+  return runCodex(args, {
+    cwd: input.cwd || process.cwd()
+  });
+}
+
+export async function runCodexClaudeCli(argv) {
+  const input = parseCommand(argv);
+
+  if (input.command === "help") {
+    console.log(usage());
+    return;
+  }
+
+  if (input.command === "install") {
+    const result = await installBridge(input);
+    if (result.stdout) {
+      console.log(result.stdout);
+    }
+    return;
+  }
+
+  if (input.command === "ask" || input.command === "review" || input.command === "delegate") {
+    const result = await runViaCodex(input);
+    if (result.stdout) {
+      console.log(result.stdout);
+    }
+    return;
+  }
+
+  throw new Error(usage());
+}

package/src/codex-cli.mjs

@@ -0,0 +1,78 @@
+import { spawn } from "node:child_process";
+
+export function buildCodexExecArgs(input) {
+  const args = ["exec"];
+
+  if (input.cwd) {
+    args.push("--cd", input.cwd);
+  }
+  if (input.model) {
+    args.push("--model", input.model);
+  }
+  if (input.sandbox) {
+    args.push("--sandbox", input.sandbox);
+  }
+  if (input.skipGitRepoCheck) {
+    args.push("--skip-git-repo-check");
+  }
+
+  args.push(input.prompt);
+  return args;
+}
+
+export function buildCodexMcpAddArgs(input) {
+  return [
+    "mcp",
+    "add",
+    input.serverName,
+    "--",
+    "node",
+    input.serverScript
+  ];
+}
+
+export async function runCodex(args, options = {}) {
+  const command = options.command || "codex";
+  const cwd = options.cwd || process.cwd();
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      env: {
+        ...process.env,
+        ...options.env
+      },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+
+    child.on("error", (error) => {
+      reject(new Error(`Failed to start Codex CLI. Ensure \`codex\` is installed and on PATH. ${error.message}`));
+    });
+
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(stderr.trim() || stdout.trim() || `Codex CLI exited with status ${code ?? "unknown"}.`));
+        return;
+      }
+
+      resolve({
+        command,
+        args,
+        cwd,
+        stdout: stdout.trim(),
+        stderr: stderr.trim()
+      });
+    });
+  });
+}

package/src/constants.mjs

@@ -0,0 +1,3 @@
+export const PACKAGE_NAME = "codex-claude-bridge";
+export const PACKAGE_VERSION = "0.1.0";
+export const DEFAULT_MCP_SERVER_NAME = "claude-bridge";

package/src/schema.mjs

@@ -0,0 +1,87 @@
+export const CLAUDE_COMMON_INPUT = {
+  cwd: {
+    type: "string",
+    description: "Working directory for the Claude Code run. Defaults to the current process directory."
+  },
+  model: {
+    type: "string",
+    description: "Optional Claude model or alias, for example `sonnet` or `claude-sonnet-4-6`."
+  },
+  permissionMode: {
+    type: "string",
+    enum: ["default", "acceptEdits", "auto", "dontAsk", "bypassPermissions", "plan"],
+    description: "Claude Code permission mode."
+  },
+  allowedTools: {
+    type: "array",
+    items: { type: "string" },
+    description: "Optional allow-list passed to `--allowedTools`."
+  },
+  disallowedTools: {
+    type: "array",
+    items: { type: "string" },
+    description: "Optional deny-list passed to `--disallowedTools`."
+  },
+  appendSystemPrompt: {
+    type: "string",
+    description: "Extra system guidance appended to Claude's default system prompt."
+  },
+  maxBudgetUsd: {
+    type: "number",
+    description: "Optional API budget cap for the run."
+  }
+};
+
+export const ASK_TOOL_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["prompt"],
+  properties: {
+    prompt: {
+      type: "string",
+      description: "Task or question for Claude Code."
+    },
+    outputFormat: {
+      type: "string",
+      enum: ["text", "json"],
+      description: "Preferred result format. Defaults to `text`."
+    },
+    ...CLAUDE_COMMON_INPUT
+  }
+};
+
+export const REVIEW_TOOL_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["prompt"],
+  properties: {
+    prompt: {
+      type: "string",
+      description: "Review instructions. Example: `Review the current diff for bugs and regressions.`"
+    },
+    outputFormat: {
+      type: "string",
+      enum: ["text", "json"],
+      description: "Preferred result format. Defaults to `text`."
+    },
+    ...CLAUDE_COMMON_INPUT
+  }
+};
+
+export const DELEGATE_TOOL_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["prompt"],
+  properties: {
+    prompt: {
+      type: "string",
+      description: "Implementation task for Claude Code."
+    },
+    outputFormat: {
+      type: "string",
+      enum: ["text", "json"],
+      description: "Preferred result format. Defaults to `text`."
+    },
+    ...CLAUDE_COMMON_INPUT
+  }
+};

package/src/server.mjs

@@ -0,0 +1,97 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+import { PACKAGE_NAME, PACKAGE_VERSION } from "./constants.mjs";
+import { ASK_TOOL_SCHEMA, DELEGATE_TOOL_SCHEMA, REVIEW_TOOL_SCHEMA } from "./schema.mjs";
+import { handleClaudeAsk, handleClaudeDelegate, handleClaudeReview } from "./tools.mjs";
+
+function jsonSchemaToZod(shape) {
+  const entries = Object.entries(shape.properties);
+  const built = {};
+
+  for (const [key, definition] of entries) {
+    let node;
+    if (definition.enum) {
+      node = z.enum(definition.enum);
+    } else if (definition.type === "string") {
+      node = z.string();
+    } else if (definition.type === "number") {
+      node = z.number();
+    } else if (definition.type === "array" && definition.items?.type === "string") {
+      node = z.array(z.string());
+    } else {
+      node = z.any();
+    }
+
+    if (!shape.required?.includes(key)) {
+      node = node.optional();
+    }
+    built[key] = node;
+  }
+
+  return z.object(built);
+}
+
+export async function createServer() {
+  const server = new McpServer({
+    name: PACKAGE_NAME,
+    version: PACKAGE_VERSION
+  });
+
+  server.registerTool(
+    "claude_ask",
+    {
+      title: "Claude Ask",
+      description: "Send a read-only prompt to Claude Code and return the result.",
+      inputSchema: jsonSchemaToZod(ASK_TOOL_SCHEMA),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    handleClaudeAsk
+  );
+
+  server.registerTool(
+    "claude_review",
+    {
+      title: "Claude Review",
+      description: "Run Claude Code as a reviewer against the current workspace.",
+      inputSchema: jsonSchemaToZod(REVIEW_TOOL_SCHEMA),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    handleClaudeReview
+  );
+
+  server.registerTool(
+    "claude_delegate",
+    {
+      title: "Claude Delegate",
+      description: "Delegate an implementation task to Claude Code, allowing file edits by default.",
+      inputSchema: jsonSchemaToZod(DELEGATE_TOOL_SCHEMA),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    handleClaudeDelegate
+  );
+
+  return server;
+}
+
+export async function startServer() {
+  const server = await createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}

package/src/tools.mjs

@@ -0,0 +1,79 @@
+import { runClaude } from "./claude-cli.mjs";
+
+function formatResult(title, result) {
+  const lines = [
+    `# ${title}`,
+    "",
+    `Command: \`claude ${result.args.map((part) => (/\s/.test(part) ? JSON.stringify(part) : part)).join(" ")}\``,
+    `Working directory: \`${result.cwd}\``,
+    ""
+  ];
+
+  if (result.stdout) {
+    lines.push("Output:", result.outputFormat === "json" ? "```json" : "```text", result.stdout, "```");
+  } else {
+    lines.push("Output:", "```text", "", "```");
+  }
+
+  if (result.stderr) {
+    lines.push("", "Stderr:", "```text", result.stderr, "```");
+  }
+
+  return lines.join("\n");
+}
+
+function toTextContent(text) {
+  return {
+    content: [
+      {
+        type: "text",
+        text
+      }
+    ]
+  };
+}
+
+export async function handleClaudeAsk(input) {
+  const result = await runClaude(input, {
+    defaults: {
+      outputFormat: input.outputFormat || "text",
+      permissionMode: input.permissionMode || "default"
+    }
+  });
+
+  return toTextContent(formatResult("Claude Ask", result));
+}
+
+export async function handleClaudeReview(input) {
+  const reviewInput = {
+    ...input,
+    appendSystemPrompt:
+      input.appendSystemPrompt ||
+      "Act as a strict code reviewer. Prioritize bugs, regressions, security issues, and missing tests."
+  };
+
+  const result = await runClaude(reviewInput, {
+    defaults: {
+      outputFormat: input.outputFormat || "text",
+      permissionMode: input.permissionMode || "default"
+    }
+  });
+
+  return toTextContent(formatResult("Claude Review", result));
+}
+
+export async function handleClaudeDelegate(input) {
+  const delegateInput = {
+    ...input,
+    permissionMode: input.permissionMode || "acceptEdits"
+  };
+
+  const result = await runClaude(delegateInput, {
+    defaults: {
+      outputFormat: input.outputFormat || "text",
+      permissionMode: delegateInput.permissionMode
+    }
+  });
+
+  return toTextContent(formatResult("Claude Delegate", result));
+}

package/tests/claude-cli.test.mjs

@@ -0,0 +1,57 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { buildClaudeArgs } from "../src/claude-cli.mjs";
+
+test("buildClaudeArgs creates the expected Claude CLI invocation", () => {
+  const args = buildClaudeArgs({
+    prompt: "Review the current diff",
+    outputFormat: "json",
+    model: "sonnet",
+    permissionMode: "dontAsk",
+    allowedTools: ["Read", "Bash(git:*)"],
+    disallowedTools: ["Edit"],
+    appendSystemPrompt: "Be strict.",
+    maxBudgetUsd: 1.5
+  });
+
+  assert.deepEqual(args, [
+    "--print",
+    "--output-format",
+    "json",
+    "--model",
+    "sonnet",
+    "--permission-mode",
+    "dontAsk",
+    "--max-budget-usd",
+    "1.5",
+    "--append-system-prompt",
+    "Be strict.",
+    "--allowedTools",
+    "Read Bash(git:*)",
+    "--disallowedTools",
+    "Edit",
+    "Review the current diff"
+  ]);
+});
+
+test("buildClaudeArgs falls back to text output when unspecified", () => {
+  const args = buildClaudeArgs(
+    {
+      prompt: "Summarize the repo"
+    },
+    {
+      outputFormat: "text",
+      permissionMode: "default"
+    }
+  );
+
+  assert.deepEqual(args, [
+    "--print",
+    "--output-format",
+    "text",
+    "--permission-mode",
+    "default",
+    "Summarize the repo"
+  ]);
+});

package/tests/codex-cli.test.mjs

@@ -0,0 +1,52 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { buildCodexExecArgs, buildCodexMcpAddArgs } from "../src/codex-cli.mjs";
+import { buildCodexClaudePrompt } from "../src/codex-claude-command.mjs";
+
+test("buildCodexExecArgs creates the expected codex exec invocation", () => {
+  const args = buildCodexExecArgs({
+    cwd: "/repo",
+    model: "gpt-5.4",
+    skipGitRepoCheck: true,
+    prompt: "Use the tool."
+  });
+
+  assert.deepEqual(args, [
+    "exec",
+    "--cd",
+    "/repo",
+    "--model",
+    "gpt-5.4",
+    "--skip-git-repo-check",
+    "Use the tool."
+  ]);
+});
+
+test("buildCodexMcpAddArgs registers the local bridge server", () => {
+  const args = buildCodexMcpAddArgs({
+    serverName: "claude-bridge",
+    serverScript: "/tmp/codex-claude-mcp.mjs"
+  });
+
+  assert.deepEqual(args, [
+    "mcp",
+    "add",
+    "claude-bridge",
+    "--",
+    "node",
+    "/tmp/codex-claude-mcp.mjs"
+  ]);
+});
+
+test("buildCodexClaudePrompt targets the review tool with a default review request", () => {
+  const prompt = buildCodexClaudePrompt({
+    command: "review",
+    cwd: "/repo"
+  });
+
+  assert.match(prompt, /claude_review/);
+  assert.match(prompt, /Return only the tool result/);
+  assert.match(prompt, /Review the current repository for bugs, regressions, and missing tests/);
+  assert.match(prompt, /"cwd":"\/repo"/);
+});

package/tests/server.test.mjs

@@ -0,0 +1,12 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { createServer } from "../src/server.mjs";
+
+test("createServer registers the expected Claude bridge tools", async () => {
+  const server = await createServer();
+  assert.deepEqual(
+    Object.keys(server._registeredTools).sort(),
+    ["claude_ask", "claude_delegate", "claude_review"]
+  );
+});

package/tests/tools.test.mjs

@@ -0,0 +1,19 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { handleClaudeAsk } from "../src/tools.mjs";
+
+test("handleClaudeAsk renders a Codex-friendly text block", async () => {
+  const originalPath = process.env.PATH;
+  process.env.PATH = "/tmp";
+
+  const response = await handleClaudeAsk({
+    prompt: "Summarize",
+    outputFormat: "text"
+  }).catch((error) => error);
+
+  process.env.PATH = originalPath;
+
+  assert.equal(response instanceof Error, true);
+  assert.match(response.message, /Failed to start Claude CLI|Ensure `claude` is installed/);
+});