tests: Add helpers for configuring MCP via codex config

Author: ishulgin

src/__tests__/CodexACPAgent/e2e/acp-e2e-test-utils.ts

@@ -1,7 +1,7 @@
 import * as acp from "@agentclientprotocol/sdk";
 import {describe, expect} from "vitest";
 import {AgentMode} from "../../../AgentMode";
-import {createSpawnedAgentFixture, type SpawnedAgentFixture} from "./spawned-agent-fixture";
+import {createSpawnedAgentFixture, type SpawnedAgentFixture,} from "./spawned-agent-fixture";
 
 export {
     createPermissionResponder,
@@ -46,7 +46,7 @@ export function expectNoPermissionRequests(fixture: SpawnedAgentFixture, session
     expectPermissionRequests(fixture, sessionId, { edit: 0, execute: 0 });
 }
 
-export async function createAuthenticatedFixture(initialMode?: AgentMode): Promise<SpawnedAgentFixture> {
+export async function createAuthenticatedFixture(initialMode?: AgentMode, mcpServers?: acp.McpServerStdio[]): Promise<SpawnedAgentFixture> {
     const apiKey = requireLiveApiKey();
     const extraEnv = initialMode ? {INITIAL_AGENT_MODE: initialMode.id} : undefined;
     return await createSpawnedFixture(async (connection, authMethods) => {
@@ -67,7 +67,7 @@ export async function createAuthenticatedFixture(initialMode?: AgentMode): Promi
         if (authenticationStatus["type"] !== "api-key") {
             throw new Error(`Unexpected authentication status: ${JSON.stringify(authenticationStatus)}`);
         }
-    }, extraEnv);
+    }, extraEnv, mcpServers);
 }
 
 export async function createGatewayFixture(
@@ -119,6 +119,7 @@ type Authenticator = (connection: acp.ClientSideConnection, authMethods: acp.Aut
 async function createSpawnedFixture(
     authenticate: Authenticator,
     extraEnv?: NodeJS.ProcessEnv,
+    mcpServers?: acp.McpServerStdio[],
 ): Promise<SpawnedAgentFixture> {
     return await createSpawnedAgentFixture(async (connection) => {
         const initializeResponse = await connection.initialize({
@@ -135,7 +136,7 @@ async function createSpawnedFixture(
         }
 
         await authenticate(connection, initializeResponse.authMethods ?? []);
-    }, extraEnv);
+    }, extraEnv, mcpServers);
 }
 
 export function requireLiveApiKey(): string {

src/__tests__/CodexACPAgent/e2e/spawned-agent-fixture.ts

@@ -43,26 +43,37 @@ type ConnectionInitializer = (connection: acp.ClientSideConnection) => Promise<v
 export async function createSpawnedAgentFixture(
     initializeConnection: ConnectionInitializer,
     extraEnv?: NodeJS.ProcessEnv,
-    paths = RuntimePaths.createTemporary(),
-    client: RecordingClient = new RecordingClient(),
+    mcpServers?: acp.McpServerStdio[],
+    paths?: RuntimePaths,
+    client?: RecordingClient,
 ): Promise<SpawnedAgentFixture> {
+    const resolvedPaths = paths ?? RuntimePaths.createTemporary();
+    const configuredMcpServers = mcpServers ?? [];
+    writeCodexHomeConfig(resolvedPaths.codexHome, {
+        model: DEFAULT_TEST_MODEL_ID.model,
+        model_reasoning_effort: DEFAULT_TEST_MODEL_ID.effort,
+        web_search: "disabled",
+    }, configuredMcpServers);
+
+    const resolvedClient = client ?? new RecordingClient();
     const agentProcess = spawn("npm", ["run", "--silent", "start"], {
         cwd: process.cwd(),
         env: {
             ...process.env,
-            CODEX_HOME: paths.codexHome,
-            APP_SERVER_LOGS: paths.appServerLogsDir,
+            CODEX_HOME: resolvedPaths.codexHome,
+            APP_SERVER_LOGS: resolvedPaths.appServerLogsDir,
             ...extraEnv,
         },
         stdio: ["pipe", "pipe", "pipe"],
     });
 
     const fixture = new SpawnedAgentFixtureImpl(
-        client,
+        resolvedClient,
         agentProcess,
-        paths,
+        resolvedPaths,
         initializeConnection,
-        extraEnv,
+        extraEnv ?? {},
+        configuredMcpServers,
     );
     await initializeConnection(fixture.connection);
     return fixture;
@@ -85,11 +96,6 @@ class RuntimePaths {
         for (const dir of [paths.rootDir, paths.codexHome, paths.workspaceDir, paths.appServerLogsDir]) {
             fs.mkdirSync(dir, {recursive: true});
         }
-        writeCodexHomeConfig(paths.codexHome, {
-            model: DEFAULT_TEST_MODEL_ID.model,
-            model_reasoning_effort: DEFAULT_TEST_MODEL_ID.effort,
-            web_search: "disabled",
-        });
         return paths;
     }
 }
@@ -146,7 +152,8 @@ class SpawnedAgentFixtureImpl implements SpawnedAgentFixture {
         private readonly agentProcess: ChildProcessWithoutNullStreams,
         private readonly paths: RuntimePaths,
         private readonly initializeConnection: ConnectionInitializer,
-        private readonly extraEnv?: NodeJS.ProcessEnv,
+        private readonly extraEnv: NodeJS.ProcessEnv,
+        private readonly mcpServers: acp.McpServerStdio[],
     ) {
         const output = Readable.toWeb(agentProcess.stdout) as ReadableStream<Uint8Array>;
         this.connection = new acp.ClientSideConnection(
@@ -168,7 +175,7 @@ class SpawnedAgentFixtureImpl implements SpawnedAgentFixture {
 
     async restart(): Promise<SpawnedAgentFixture> {
         await this.stopProcess(false);
-        return await createSpawnedAgentFixture(this.initializeConnection, this.extraEnv, this.paths, this.client);
+        return await createSpawnedAgentFixture(this.initializeConnection, this.extraEnv, this.mcpServers, this.paths, this.client);
     }
 
     writeSkill(skill: TestSkill, rootDir?: string): void {

src/__tests__/acp-test-utils.ts

@@ -1,8 +1,8 @@
+import type {AgentSideConnection, McpServerStdio, RequestPermissionResponse} from "@agentclientprotocol/sdk";
 import {CodexAcpClient} from '../CodexAcpClient';
-import {type CodexConnectionEvent, CodexAppServerClient} from '../CodexAppServerClient';
+import {CodexAppServerClient, type CodexConnectionEvent} from '../CodexAppServerClient';
 import {startCodexConnection} from "../CodexJsonRpcConnection";
 import {CodexAcpServer, type SessionState} from "../CodexAcpServer";
-import type {AgentSideConnection, RequestPermissionResponse} from "@agentclientprotocol/sdk";
 import type {ServerNotification} from "../app-server";
 import type {MessageConnection} from "vscode-jsonrpc/node";
 import path from "node:path";
@@ -176,17 +176,37 @@ function createTestCodexHome(): string {
     return codexHome;
 }
 
-export function writeCodexHomeConfig(codexHome: string, extras: Record<string, string> = {}): void {
+export function writeCodexHomeConfig(
+    codexHome: string,
+    extras: Record<string, string> = {},
+    mcpServers: McpServerStdio[] = [],
+): void {
     const entries: Record<string, string> = {
         cli_auth_credentials_store: "file",
         ...extras,
     };
-    const body = Object.entries(entries)
+    let body = Object.entries(entries)
         .map(([key, value]) => `${key} = "${value}"`)
         .join("\n");
+    for (const server of mcpServers) {
+        body += `\n\n[mcp_servers."${escapeTOML(server.name)}"]`;
+        body += `\ncommand = "${escapeTOML(server.command)}"`;
+        const argsToml = server.args.map(a => `"${escapeTOML(a)}"`).join(", ");
+        body += `\nargs = [${argsToml}]`;
+        if (server.env && server.env.length > 0) {
+            const envPairs = server.env
+                .map(e => `${e.name} = "${escapeTOML(e.value)}"`)
+                .join(", ");
+            body += `\nenv = {${envPairs}}`;
+        }
+    }
     fs.writeFileSync(path.join(codexHome, "config.toml"), body, "utf8");
 }
 
+function escapeTOML(value: string): string {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
 export function removeDirectoryWithRetry(directory: string): void {
     for (let attempt = 0; attempt < 5; attempt += 1) {
         try {