Add e2e tests for session modes and refactor status checks

Author: ishulgin

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

@@ -4,7 +4,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import {Readable, Writable} from "node:stream";
-import {describe, vi} from "vitest";
+import {describe, expect, vi} from "vitest";
 import {removeDirectoryWithRetry} from "../../acp-test-utils";
 
 export const RUN_E2E_TESTS = process.env["RUN_E2E_TESTS"] === "true";
@@ -25,6 +25,17 @@ export function describeE2E(name: string, factory: () => void, timeoutMs = DEFAU
     describe.skipIf(!RUN_E2E_TESTS)(name, {timeout: timeoutMs}, factory);
 }
 
+export async function expectStatus(
+    session: SpawnedSessionFixture,
+    fields: Record<string, unknown>,
+): Promise<void> {
+    await session.expectPromptText("/status", (text) => {
+        for (const [field, value] of Object.entries(fields)) {
+            expect(text).toContain(`**${field}:** ${String(value)}`);
+        }
+    });
+}
+
 interface TestSkill {
     readonly name: string;
     readonly description: string;
@@ -68,7 +79,8 @@ export async function createFixtureWithSkill(skill: TestSkill): Promise<SpawnedA
 }
 
 export async function createAuthenticatedFixture(
-    runtimePaths = createTemporaryRuntimePaths()
+    runtimePaths = createTemporaryRuntimePaths(),
+    extraEnv?: NodeJS.ProcessEnv,
 ): Promise<SpawnedAgentFixture> {
     const apiKey = requireLiveApiKey();
     return await createSpawnedFixture(async (connection, authMethods) => {
@@ -89,7 +101,7 @@ export async function createAuthenticatedFixture(
         if (authenticationStatus["type"] !== "api-key") {
             throw new Error(`Unexpected authentication status: ${JSON.stringify(authenticationStatus)}`);
         }
-    }, runtimePaths);
+    }, runtimePaths, extraEnv);
 }
 
 export interface GatewayFixtureOptions {
@@ -128,13 +140,15 @@ type Authenticator = (connection: acp.ClientSideConnection, authMethods: acp.Aut
 async function createSpawnedFixture(
     authenticate: Authenticator,
     runtimePaths: RuntimePaths,
+    extraEnv?: NodeJS.ProcessEnv,
 ): Promise<SpawnedAgentFixture> {
     const agentProcess = spawn("npm", ["run", "--silent", "start"], {
         cwd: process.cwd(),
         env: {
             ...process.env,
             CODEX_HOME: runtimePaths.codexHome,
             APP_SERVER_LOGS: runtimePaths.appServerLogsDir,
+            ...extraEnv,
         },
         stdio: ["pipe", "pipe", "pipe"],
     });

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

@@ -1,9 +1,11 @@
 import {afterEach, expect, it} from "vitest";
+import {AgentMode} from "../../../AgentMode";
 import {
     createAuthenticatedFixture,
     createFixtureWithSkill,
     createGatewayFixture,
     describeE2E,
+    expectStatus,
     requireLiveApiKey,
     type SpawnedAgentFixture,
 } from "./acp-e2e-test-utils";
@@ -60,8 +62,43 @@ describeE2E("E2E tests", () => {
             sessionId: session.response.sessionId,
             modelId: selectedModelId,
         });
-        await session.expectPromptText("/status", (text) => {
-            expect(text).toContain(`**Model:** ${selectedModelId}`);
+        await expectStatus(session, {Model: selectedModelId});
+    });
+
+    it("changes session mode via setSessionMode and reflects it in /status", async () => {
+        fixture = await createAuthenticatedFixture();
+        const session = await fixture.createSession();
+
+        const modes = session.response.modes;
+        expect(modes?.currentModeId).toBe(AgentMode.DEFAULT_AGENT_MODE.id);
+        expect(modes?.availableModes.map((mode) => mode.id)).toEqual(
+            AgentMode.all().map((mode) => mode.id),
+        );
+
+        const targetMode = AgentMode.AgentFullAccess;
+        await fixture.connection.setSessionMode({
+            sessionId: session.response.sessionId,
+            modeId: targetMode.id,
+        });
+
+        await expectStatus(session, {
+            Approval: targetMode.approvalPolicy,
+            Sandbox: targetMode.sandboxMode,
+        });
+    });
+
+    it("respects INITIAL_AGENT_MODE when seeding the initial session mode", async () => {
+        const initialMode = AgentMode.ReadOnly;
+        fixture = await createAuthenticatedFixture(undefined, {
+            INITIAL_AGENT_MODE: initialMode.id,
+        });
+        const session = await fixture.createSession();
+
+        expect(session.response.modes?.currentModeId).toBe(initialMode.id);
+
+        await expectStatus(session, {
+            Approval: initialMode.approvalPolicy,
+            Sandbox: initialMode.sandboxMode,
         });
     });