fix(coordinator): launch codex with inline MCP config

brooksc · brooksc · commit 05344e29b161 · 2026-05-19T22:56:00.000-07:00
diff --git a/electron/ipc/register.ts b/electron/ipc/register.ts
@@ -31,6 +31,7 @@ import { initPrChecks, startPrChecksWatcher, stopPrChecksWatcher, isPrUrl } from
 import { readCoverageSummary } from './coverage.js';
 import { startRemoteServer, getMCPLogs } from '../remote/server.js';
 import { atomicWriteFileSync } from '../mcp/atomic.js';
+import { buildMcpLaunchArgs } from '../mcp/agent-args.js';
 import {
   getGitIgnoredDirs,
   getMainBranch,
@@ -104,7 +105,7 @@ export interface CoordinatorMCPConfigOpts {
   propagateSkipPermissions?: boolean;
 }
 
-/** Builds the coordinator `.mcp.json` / `--mcp-config` file content. */
+/** Builds the coordinator MCP server config used for launch args and `.mcp.json`. */
 export function buildCoordinatorMCPConfig(opts: CoordinatorMCPConfigOpts): {
   mcpServers: {
     'parallel-code': {
@@ -1596,24 +1597,30 @@ export function registerAllHandlers(win: BrowserWindow): void {
         lastMcpConfigPath = configPath;
         console.warn('[MCP] Config written to:', configPath);
       }
+      const mcpLaunchArgs = buildMcpLaunchArgs(
+        args.agentCommand ?? 'claude',
+        configPath,
+        mcpConfig,
+      );
       console.warn('[MCP] Server path:', mcpServerPath);
       console.warn('[MCP] Remote URL:', redactServerUrl(serverUrl));
 
       return {
         configPath,
+        mcpLaunchArgs,
         serverUrl,
         port: remoteServer.port,
       };
     },
   );
 
   ipcMain.handle(IPC.StopMCPServer, async () => {
-    // The MCP server process is spawned by Claude Code (via --mcp-config),
+    // The MCP server process is spawned by the agent CLI via launch args,
     // not by us. This handler is a no-op but kept for API completeness.
   });
 
   ipcMain.handle(IPC.GetMCPStatus, () => {
-    // The MCP server process is spawned by Claude Code (via --mcp-config),
+    // The MCP server process is spawned by the agent CLI via launch args,
     // not by us. We report whether the remote HTTP server that the MCP
     // server connects to is running — if it's up, MCP tools should work.
     const remoteRunning = remoteServer !== null;
diff --git a/electron/mcp/agent-args.test.ts b/electron/mcp/agent-args.test.ts
@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildCodexMcpConfigOverride, buildMcpLaunchArgs, isCodexCommand } from './agent-args.js';
+
+const config = {
+  mcpServers: {
+    'parallel-code': {
+      command: 'node',
+      args: ['/tmp/mcp-server.cjs', '--url', 'http://127.0.0.1:1234', '--coordinator-id', 'task-1'],
+      env: {
+        PARALLEL_CODE_MCP_TOKEN: 'token-1',
+      },
+    },
+  },
+};
+
+describe('MCP agent launch args', () => {
+  it('detects codex commands by executable name', () => {
+    expect(isCodexCommand('codex')).toBe(true);
+    expect(isCodexCommand('/opt/homebrew/bin/codex')).toBe(true);
+    expect(isCodexCommand('claude')).toBe(false);
+  });
+
+  it('builds Codex inline config overrides instead of --mcp-config', () => {
+    expect(buildMcpLaunchArgs('codex', '/tmp/config.json', config)).toEqual([
+      '--config',
+      buildCodexMcpConfigOverride(config),
+    ]);
+  });
+
+  it('uses --mcp-config for Claude-compatible agents', () => {
+    expect(buildMcpLaunchArgs('claude', '/tmp/config.json', config)).toEqual([
+      '--mcp-config',
+      '/tmp/config.json',
+    ]);
+  });
+});
diff --git a/electron/mcp/agent-args.ts b/electron/mcp/agent-args.ts
@@ -0,0 +1,45 @@
+interface ParallelCodeMcpServerConfig {
+  command: string;
+  args: string[];
+  env: Record<string, string>;
+}
+
+export interface ParallelCodeMcpConfig {
+  mcpServers: {
+    'parallel-code': ParallelCodeMcpServerConfig;
+  };
+}
+
+export function isCodexCommand(command: string): boolean {
+  return command.split('/').pop()?.includes('codex') === true;
+}
+
+function tomlString(value: string): string {
+  return JSON.stringify(value);
+}
+
+function tomlStringArray(values: string[]): string {
+  return `[${values.map(tomlString).join(', ')}]`;
+}
+
+function tomlStringMap(values: Record<string, string>): string {
+  return `{ ${Object.entries(values)
+    .map(([key, value]) => `${key} = ${tomlString(value)}`)
+    .join(', ')} }`;
+}
+
+export function buildCodexMcpConfigOverride(config: ParallelCodeMcpConfig): string {
+  const server = config.mcpServers['parallel-code'];
+  return `mcp_servers.parallel-code={ command = ${tomlString(server.command)}, args = ${tomlStringArray(server.args)}, env = ${tomlStringMap(server.env)} }`;
+}
+
+export function buildMcpLaunchArgs(
+  command: string,
+  configPath: string | undefined,
+  config: ParallelCodeMcpConfig,
+): string[] {
+  if (isCodexCommand(command)) {
+    return ['--config', buildCodexMcpConfigOverride(config)];
+  }
+  return configPath ? ['--mcp-config', configPath] : [];
+}
diff --git a/electron/mcp/coordinator.ts b/electron/mcp/coordinator.ts
@@ -16,6 +16,7 @@ import {
 import { join, dirname } from 'path';
 import os from 'os';
 import { getSubTaskMcpConfigPath } from './config.js';
+import { buildMcpLaunchArgs } from './agent-args.js';
 import { validateBranchName } from './validation.js';
 import { atomicWriteFileSync, atomicWriteFile } from './atomic.js';
 import { ReplayCache } from './replay-cache.js';
@@ -604,8 +605,9 @@ export class Coordinator {
       // Write a per-sub-task MCP config so the agent can call signal_done.
       // In Docker mode, write to the coordinator's .parallel-code/ dir (which IS the explicitly
       // mounted volume) rather than the sub-task worktree (which may not be in the container).
-      // Always pass --mcp-config explicitly so Claude doesn't rely on auto-discovery.
+      // Always pass explicit MCP launch args so agents don't rely on auto-discovery.
       const mcpServerInfoForTask = coordinatorState.mcpServerInfo;
+      let subTaskMcpConfig: Parameters<typeof buildMcpLaunchArgs>[2] | undefined;
       if (mcpServerInfoForTask) {
         const { serverUrl, subtaskToken, serverPath } = mcpServerInfoForTask;
         const doneToken = randomBytes(24).toString('base64url');
@@ -623,6 +625,7 @@ export class Coordinator {
             },
           },
         };
+        subTaskMcpConfig = mcpConfig;
         const configPath = getSubTaskMcpConfigPath(dockerContainerName, serverPath, task.id);
         await atomicWriteFile(configPath, JSON.stringify(mcpConfig, null, 2), { mode: 0o600 });
         subTaskMcpConfigPath = configPath;
@@ -635,7 +638,9 @@ export class Coordinator {
         ...agentArgs,
         ...(coordinatorState.propagateSkipPermissions ? getSkipPermissionsArgs(agentCommand) : []),
       ];
-      const mcpArgs = subTaskMcpConfigPath ? ['--mcp-config', subTaskMcpConfigPath] : [];
+      const mcpArgs = subTaskMcpConfig
+        ? buildMcpLaunchArgs(agentCommand, subTaskMcpConfigPath, subTaskMcpConfig)
+        : [];
       const agentFinalArgs = [...baseArgs, ...mcpArgs];
 
       // In Docker coordinator mode, each sub-task gets its own `docker run` container
diff --git a/src/App.tsx b/src/App.tsx
@@ -52,6 +52,7 @@ import {
   initMCPListeners,
   markTaskMcpPending,
   markTaskMcpReady,
+  setTaskMcpLaunchArgs,
   markTaskMcpError,
 } from './store/store';
 import { isGitHubUrl } from './lib/github-url';
@@ -359,7 +360,7 @@ function App() {
           : undefined;
       markTaskMcpPending(taskId);
       mcpRestorePromises.push(
-        invoke(IPC.StartMCPServer, {
+        invoke<{ mcpLaunchArgs?: string[] }>(IPC.StartMCPServer, {
           coordinatorTaskId: task.id,
           projectId: task.projectId,
           projectRoot,
@@ -371,7 +372,10 @@ function App() {
           dockerContainerName,
           dockerImage: task.dockerMode ? task.dockerImage : undefined,
         })
-          .then(() => markTaskMcpReady(taskId))
+          .then((result) => {
+            setTaskMcpLaunchArgs(taskId, result?.mcpLaunchArgs);
+            markTaskMcpReady(taskId);
+          })
           .catch((err) => {
             console.warn(`[MCP] Failed to restore MCP server for coordinator task ${taskId}:`, err);
             markTaskMcpError(taskId, String(err));
diff --git a/src/components/TaskAITerminal.tsx b/src/components/TaskAITerminal.tsx
@@ -28,6 +28,7 @@ import { createHighlightedMarkdown } from '../lib/marked-shiki';
 import type { Task } from '../store/types';
 import type { AgentDef } from '../ipc/types';
 import type { PromptInputHandle } from './PromptInput';
+import { buildTaskAgentArgs } from '../lib/agent-args';
 
 function aiTerminalPanelId(agentId: string): string {
   return `ai-terminal:${agentId}`;
@@ -588,15 +589,7 @@ function AgentTerminalPane(props: {
                 agentId={a().id}
                 isFocused={isPanelFocused(props.task.id, aiTerminalPanelId(props.agentId))}
                 command={a().def.command}
-                args={[
-                  ...(a().resumed && a().def.resume_args?.length
-                    ? (a().def.resume_args ?? [])
-                    : a().def.args),
-                  ...(props.task.skipPermissions && a().def.skip_permissions_args?.length
-                    ? (a().def.skip_permissions_args ?? [])
-                    : []),
-                  ...(props.task.mcpConfigPath ? ['--mcp-config', props.task.mcpConfigPath] : []),
-                ]}
+                args={buildTaskAgentArgs(a().def, props.task, a().resumed)}
                 cwd={props.task.worktreePath}
                 stepsEnabled={props.task.stepsEnabled}
                 dockerMode={
diff --git a/src/lib/agent-args.test.ts b/src/lib/agent-args.test.ts
@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildTaskAgentArgs } from './agent-args';
+
+const codexAgent = {
+  id: 'codex',
+  name: 'Codex',
+  description: 'Codex agent',
+  command: 'codex',
+  args: ['resume', '--last'],
+  resume_args: ['resume', '--last'],
+  skip_permissions_args: ['--dangerously-bypass-approvals-and-sandbox'],
+};
+
+const claudeAgent = {
+  id: 'claude',
+  name: 'Claude',
+  description: 'Claude agent',
+  command: 'claude',
+  args: [],
+  resume_args: [],
+  skip_permissions_args: ['--dangerously-skip-permissions'],
+};
+
+describe('buildTaskAgentArgs', () => {
+  it('uses explicit MCP launch args when provided', () => {
+    expect(
+      buildTaskAgentArgs(
+        codexAgent,
+        {
+          skipPermissions: true,
+          mcpConfigPath: '/tmp/mcp.json',
+          mcpLaunchArgs: ['--config', 'mcp_servers.parallel-code={ command = "node" }'],
+        },
+        false,
+      ),
+    ).toEqual([
+      'resume',
+      '--last',
+      '--dangerously-bypass-approvals-and-sandbox',
+      '--config',
+      'mcp_servers.parallel-code={ command = "node" }',
+    ]);
+  });
+
+  it('does not fall back to --mcp-config for Codex', () => {
+    expect(
+      buildTaskAgentArgs(
+        codexAgent,
+        {
+          skipPermissions: false,
+          mcpConfigPath: '/tmp/mcp.json',
+        },
+        false,
+      ),
+    ).toEqual(['resume', '--last']);
+  });
+
+  it('keeps --mcp-config fallback for Claude-compatible agents', () => {
+    expect(
+      buildTaskAgentArgs(
+        claudeAgent,
+        {
+          skipPermissions: false,
+          mcpConfigPath: '/tmp/mcp.json',
+        },
+        false,
+      ),
+    ).toEqual(['--mcp-config', '/tmp/mcp.json']);
+  });
+});
diff --git a/src/lib/agent-args.ts b/src/lib/agent-args.ts
@@ -0,0 +1,25 @@
+import type { AgentDef } from '../ipc/types';
+import type { Task } from '../store/types';
+
+function isCodexCommand(command: string): boolean {
+  return command.split('/').pop()?.includes('codex') === true;
+}
+
+function legacyMcpConfigArgs(command: string, mcpConfigPath: string | undefined): string[] {
+  if (!mcpConfigPath || isCodexCommand(command)) return [];
+  return ['--mcp-config', mcpConfigPath];
+}
+
+export function buildTaskAgentArgs(
+  agentDef: AgentDef,
+  task: Pick<Task, 'skipPermissions' | 'mcpConfigPath' | 'mcpLaunchArgs'>,
+  resumed: boolean,
+): string[] {
+  return [
+    ...(resumed && agentDef.resume_args?.length ? (agentDef.resume_args ?? []) : agentDef.args),
+    ...(task.skipPermissions && agentDef.skip_permissions_args?.length
+      ? (agentDef.skip_permissions_args ?? [])
+      : []),
+    ...(task.mcpLaunchArgs ?? legacyMcpConfigArgs(agentDef.command, task.mcpConfigPath)),
+  ];
+}
diff --git a/src/store/store.ts b/src/store/store.ts
@@ -61,6 +61,7 @@ export {
   setTaskControl,
   markTaskMcpPending,
   markTaskMcpReady,
+  setTaskMcpLaunchArgs,
   markTaskMcpError,
   retryTaskMcpStartup,
 } from './tasks';
diff --git a/src/store/tasks.ts b/src/store/tasks.ts
@@ -188,13 +188,17 @@ export async function createTask(opts: CreateTaskOptions): Promise<string> {
 
   // Start MCP server BEFORE adding task to store — the store update triggers
   // a reactive render of TerminalView which spawns the PTY immediately.
-  // If mcpConfigPath isn't set yet, the --mcp-config arg is missing.
+  // If MCP launch args aren't set yet, the coordinator agent starts without MCP wiring.
   let mcpConfigPath: string | undefined;
+  let mcpLaunchArgs: string[] | undefined;
   if (opts.coordinatorMode) {
     // When running in Docker, sub-agents will be spawned via `docker exec` into this container.
     const dockerContainerName = dockerMode ? `parallel-code-${agentId.slice(0, 12)}` : undefined;
     try {
-      const mcpResult = await invoke<{ configPath: string | undefined }>(IPC.StartMCPServer, {
+      const mcpResult = await invoke<{
+        configPath: string | undefined;
+        mcpLaunchArgs?: string[];
+      }>(IPC.StartMCPServer, {
         coordinatorTaskId: taskId,
         projectId,
         projectRoot,
@@ -207,6 +211,7 @@ export async function createTask(opts: CreateTaskOptions): Promise<string> {
         dockerImage,
       });
       mcpConfigPath = mcpResult.configPath ?? undefined;
+      mcpLaunchArgs = mcpResult.mcpLaunchArgs;
       console.warn('[MCP] Coordinator config path:', mcpConfigPath);
       await invoke(IPC.MCP_CoordinatorRegistered, {
         coordinatorTaskId: taskId,
@@ -270,6 +275,7 @@ export async function createTask(opts: CreateTaskOptions): Promise<string> {
       : undefined,
     controlledBy: opts.coordinatorMode ? 'coordinator' : undefined,
     mcpConfigPath,
+    mcpLaunchArgs,
     // Coordinator tasks call StartMCPServer before entering the store, so MCP is ready immediately.
     mcpStartupStatus: opts.coordinatorMode ? ('ready' as const) : undefined,
   };
@@ -1236,6 +1242,10 @@ export function markTaskMcpReady(taskId: string): void {
   if (store.tasks[taskId]) setStore('tasks', taskId, 'mcpStartupStatus', 'ready');
 }
 
+export function setTaskMcpLaunchArgs(taskId: string, args: string[] | undefined): void {
+  if (store.tasks[taskId]) setStore('tasks', taskId, 'mcpLaunchArgs', args);
+}
+
 export function markTaskMcpError(taskId: string, errorMsg: string): void {
   if (!store.tasks[taskId]) return;
   // eslint-disable-next-line no-control-regex -- strip escape chars to prevent injection
@@ -1260,7 +1270,7 @@ export function retryTaskMcpStartup(taskId: string): Promise<void> {
       task.dockerMode && task.agentIds[0]
         ? `parallel-code-${task.agentIds[0].slice(0, 12)}`
         : undefined;
-    return invoke(IPC.StartMCPServer, {
+    return invoke<{ mcpLaunchArgs?: string[] }>(IPC.StartMCPServer, {
       coordinatorTaskId: task.id,
       projectId: task.projectId,
       projectRoot,
@@ -1272,7 +1282,10 @@ export function retryTaskMcpStartup(taskId: string): Promise<void> {
       dockerContainerName,
       dockerImage: task.dockerImage,
     })
-      .then(() => markTaskMcpReady(taskId))
+      .then((result) => {
+        setTaskMcpLaunchArgs(taskId, result?.mcpLaunchArgs);
+        markTaskMcpReady(taskId);
+      })
       .catch((err: unknown) => markTaskMcpError(taskId, String(err)));
   }
 
diff --git a/src/store/types.ts b/src/store/types.ts
