@agentrq/acp-gateway 0.2.3 → 0.2.5

package/dist/__tests__/index.test.js

@@ -1,13 +1,30 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { Writable, Readable } from "node:stream";
-import { createAcpSessionSwitcher, checkForNextTask, mapMcpServers, TaskQueue, getOrCreateSession, activeSessions, pickHumanApprovalMode, enforceHumanApprovalMode, } from "../index.js";
-vi.mock("node:child_process", () => {
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { EventEmitter } from "node:events";
+import * as acp from "@agentclientprotocol/sdk";
+import { createAcpSessionSwitcher, checkForNextTask, mapMcpServers, TaskQueue, getOrCreateSession, activeSessions, authConfig, createSessionWithAuth, isInteractiveTerminal, openAgentConnection, parseGatewayArgs, assertAgentRunnable, helpText, isRunnable, printHelp, resolveAgentCommand, runListAgents, pickHumanApprovalMode, enforceHumanApprovalMode, handleAgentModeChange, runAgentCommand, } from "../index.js";
+import { AUTH_REQUIRED_CODE } from "../auth.js";
+/**
+ * A stand-in for the workspace bridge.
+ *
+ * The ACP client registers a verdict listener on it as soon as it is built, so
+ * a bare object is not enough — the real bridge is an EventEmitter.
+ */
+function fakeBridge() {
+    return new EventEmitter();
+}
+// Real emitters so the agent-process lifecycle handlers can be exercised.
+const { spawnedAgents } = vi.hoisted(() => ({ spawnedAgents: [] }));
+vi.mock("node:child_process", async () => {
+    const { EventEmitter } = await import("node:events");
+    const { Writable, Readable } = await import("node:stream");
     return {
-        spawn: vi.fn().mockReturnValue({
-            stdin: new Writable({ write(chunk, encoding, callback) { callback(); } }),
-            stdout: new Readable({ read() { this.push(null); } }),
-            kill: vi.fn(),
-            on: vi.fn(),
+        spawn: vi.fn(() => {
+            const child = new EventEmitter();
+            child.stdin = new Writable({ write(chunk, encoding, callback) { callback(); } });
+            child.stdout = new Readable({ read() { this.push(null); } });
+            child.kill = vi.fn();
+            spawnedAgents.push(child);
+            return child;
         }),
     };
 });
@@ -59,6 +76,44 @@ describe("index", () => {
                     headers: []
                 }]);
         });
+        it("should map an sse server as its own transport", () => {
+            const configs = [{
+                    type: "sse",
+                    name: "events",
+                    url: "http://localhost:8000/sse",
+                }];
+            expect(mapMcpServers(configs, { mcpCapabilities: { sse: true } })).toEqual([{
+                    type: "sse",
+                    name: "events",
+                    url: "http://localhost:8000/sse",
+                    headers: [],
+                }]);
+        });
+        it("should leave out a transport the agent says it does not support", () => {
+            const errorSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+            const configs = [
+                { type: "http", name: "remote", url: "http://localhost:8000" },
+                { type: "stdio", name: "local", command: "npx" },
+            ];
+            // An agent may refuse the whole session/new rather than skip one entry.
+            const result = mapMcpServers(configs, {
+                mcpCapabilities: { http: false, sse: false },
+            });
+            expect(result.map((s) => s.name)).toEqual(["local"]);
+            expect(errorSpy.mock.calls.flat().join("\n")).toContain('Not passing MCP server "remote"');
+            errorSpy.mockRestore();
+        });
+        it("should still hand over a transport the agent never mentions", () => {
+            const errorSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+            const configs = [
+                { type: "http", name: "remote", url: "http://localhost:8000" },
+            ];
+            // A terse agent is likelier than one that genuinely cannot reach HTTP,
+            // and dropping this would take the workspace's own server away from it.
+            expect(mapMcpServers(configs, {}).map((s) => s.name)).toEqual(["remote"]);
+            expect(mapMcpServers(configs).map((s) => s.name)).toEqual(["remote"]);
+            errorSpy.mockRestore();
+        });
         it("should correctly map stdio servers", () => {
             const configs = [{
                     type: "stdio",
@@ -321,7 +376,7 @@ describe("index", () => {
             activeSessions.clear();
         });
         it("should spawn a new session when not cached", async () => {
-            const mockBridge = {};
+            const mockBridge = fakeBridge();
             const configs = [];
             const agentrqConfig = { env: {} };
             const session = await getOrCreateSession("T-New", ["node", "agent.js"], configs, agentrqConfig, mockBridge);
@@ -330,7 +385,7 @@ describe("index", () => {
             expect(activeSessions.has("T-New")).toBe(true);
         });
         it("should return cached session when already created", async () => {
-            const mockBridge = {};
+            const mockBridge = fakeBridge();
             const configs = [];
             const agentrqConfig = { env: {} };
             const session1 = await getOrCreateSession("T-Cache", ["node", "agent.js"], configs, agentrqConfig, mockBridge);
@@ -338,7 +393,7 @@ describe("index", () => {
             expect(session1).toBe(session2);
         });
         it("should declare elicitation support when initializing the ACP connection", async () => {
-            const mockBridge = {};
+            const mockBridge = fakeBridge();
             const configs = [];
             const agentrqConfig = { env: {} };
             const session = await getOrCreateSession("T-Elicit", ["node", "agent.js"], configs, agentrqConfig, mockBridge);
@@ -348,6 +403,424 @@ describe("index", () => {
                 }),
             }));
         });
+        it("should declare whether it can host a terminal login", async () => {
+            const mockBridge = fakeBridge();
+            const session = await getOrCreateSession("T-Auth-Cap", ["node", "agent.js"], [], { env: {} }, mockBridge);
+            expect(session.connection.initialize).toHaveBeenCalledWith(expect.objectContaining({
+                clientCapabilities: expect.objectContaining({
+                    auth: { terminal: isInteractiveTerminal() },
+                }),
+            }));
+        });
+        it("should log in and retry when the agent refuses the session", async () => {
+            const authenticate = vi.fn().mockResolvedValue({});
+            const newSession = vi
+                .fn()
+                .mockRejectedValueOnce(Object.assign(new Error("Authentication required"), { code: AUTH_REQUIRED_CODE }))
+                .mockResolvedValue({ sessionId: "authed-sess" });
+            vi.mocked(acp.ClientSideConnection).mockImplementationOnce(function () {
+                return {
+                    initialize: vi.fn().mockResolvedValue({
+                        protocolVersion: "0.1.0",
+                        authMethods: [{ id: "agent-login", name: "Agent login" }],
+                    }),
+                    newSession,
+                    authenticate,
+                    prompt: vi.fn(),
+                };
+            });
+            const session = await getOrCreateSession("T-Login", ["node", "agent.js"], [], { env: {} }, fakeBridge());
+            expect(authenticate).toHaveBeenCalledWith({ methodId: "agent-login" });
+            expect(newSession).toHaveBeenCalledTimes(2);
+            expect(session.sessionId).toBe("authed-sess");
+        });
+        it("should drop the cached session when the agent process dies", async () => {
+            const mockBridge = fakeBridge();
+            await getOrCreateSession("T-Exit", ["node", "agent.js"], [], { env: {} }, mockBridge);
+            expect(activeSessions.has("T-Exit")).toBe(true);
+            spawnedAgents[spawnedAgents.length - 1].emit("exit", 1, null);
+            expect(activeSessions.has("T-Exit")).toBe(false);
+        });
+    });
+    describe("openAgentConnection", () => {
+        beforeEach(() => {
+            spawnedAgents.length = 0;
+        });
+        it("should report the agent's login methods and survive process failures", async () => {
+            const errorSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+            vi.mocked(acp.ClientSideConnection).mockImplementationOnce(function () {
+                return {
+                    initialize: vi.fn().mockResolvedValue({
+                        protocolVersion: "0.1.0",
+                        authMethods: [{ id: "agent-login", name: "Agent login" }],
+                    }),
+                };
+            });
+            const onExit = vi.fn();
+            const agent = await openAgentConnection({
+                acpCmdArgs: ["node", "agent.js"],
+                mcpBridge: fakeBridge(),
+                label: "login",
+                onExit,
+            });
+            expect(agent.initResult.authMethods).toHaveLength(1);
+            expect(errorSpy.mock.calls.flat().join("\n")).toContain("Agent login (agent-login)");
+            agent.process.emit("error", new Error("spawn failed"));
+            agent.process.stdin.emit("error", new Error("EPIPE"));
+            expect(onExit).toHaveBeenCalledTimes(1);
+            errorSpy.mockRestore();
+        });
+    });
+    describe("createSessionWithAuth", () => {
+        const auth = {
+            methods: [{ id: "agent-login", name: "Agent login" }],
+            launch: { command: "node", args: ["agent.js"] },
+        };
+        it("should start the session directly when no login is needed", async () => {
+            const connection = {
+                newSession: vi.fn().mockResolvedValue({ sessionId: "s1" }),
+                authenticate: vi.fn(),
+            };
+            const result = await createSessionWithAuth(connection, {}, auth);
+            expect(result.sessionId).toBe("s1");
+            expect(connection.authenticate).not.toHaveBeenCalled();
+        });
+        it("should surface failures that are not about authentication", async () => {
+            const connection = {
+                newSession: vi.fn().mockRejectedValue(new Error("cwd does not exist")),
+                authenticate: vi.fn(),
+            };
+            await expect(createSessionWithAuth(connection, {}, auth)).rejects.toThrow("cwd does not exist");
+            expect(connection.authenticate).not.toHaveBeenCalled();
+        });
+    });
+    describe("parseGatewayArgs", () => {
+        it("should default to bridging tasks with a concurrency of 2", () => {
+            expect(parseGatewayArgs([])).toEqual({
+                maxConcurrency: 2,
+                permissionTimeoutMs: 30 * 60_000,
+                command: "run",
+                allowUnverifiedAgent: false,
+                rest: [],
+            });
+        });
+        it("should take the permission timeout in minutes", () => {
+            expect(parseGatewayArgs(["--permission-timeout", "5"]).permissionTimeoutMs).toBe(300_000);
+            // Zero is a deliberate "wait indefinitely", so it must not be ignored.
+            expect(parseGatewayArgs(["--permission-timeout", "0"]).permissionTimeoutMs).toBe(0);
+        });
+        it("should keep the default when the timeout makes no sense", () => {
+            expect(parseGatewayArgs(["--permission-timeout"]).permissionTimeoutMs).toBe(30 * 60_000);
+            expect(parseGatewayArgs(["--permission-timeout", "soon"]).permissionTimeoutMs).toBe(30 * 60_000);
+            expect(parseGatewayArgs(["--permission-timeout", "-5"]).permissionTimeoutMs).toBe(30 * 60_000);
+        });
+        it("should accept both spellings of the concurrency flag", () => {
+            expect(parseGatewayArgs(["--max-concurrency", "4"]).maxConcurrency).toBe(4);
+            expect(parseGatewayArgs(["--maxConcurrency", "8"]).maxConcurrency).toBe(8);
+        });
+        it("should keep the default when the concurrency value is missing or not a number", () => {
+            expect(parseGatewayArgs(["--max-concurrency"]).maxConcurrency).toBe(2);
+            expect(parseGatewayArgs(["--max-concurrency", "many"]).maxConcurrency).toBe(2);
+            expect(parseGatewayArgs(["--max-concurrency", "--logout"])).toMatchObject({
+                maxConcurrency: 2,
+                command: "logout",
+            });
+        });
+        it("should read the preferred auth method", () => {
+            expect(parseGatewayArgs(["--auth-method", "oauth"])).toMatchObject({
+                maxConcurrency: 2,
+                command: "run",
+                authMethodId: "oauth",
+            });
+            expect(parseGatewayArgs(["--auth-method"]).authMethodId).toBeUndefined();
+        });
+        it("should recognise the auth commands", () => {
+            expect(parseGatewayArgs(["--login"])).toMatchObject({ maxConcurrency: 2, command: "login" });
+            expect(parseGatewayArgs(["--login", "oauth"])).toMatchObject({
+                maxConcurrency: 2,
+                command: "login",
+                authMethodId: "oauth",
+            });
+            expect(parseGatewayArgs(["--logout"]).command).toBe("logout");
+            expect(parseGatewayArgs(["--list-auth-methods"]).command).toBe("list-auth-methods");
+        });
+        it("should keep tokens it does not recognise as the agent command", () => {
+            const options = parseGatewayArgs(["--verbose", "--login"]);
+            expect(options.command).toBe("login");
+            expect(options.rest).toEqual(["--verbose"]);
+        });
+        it("should collect an agent command given without a -- separator", () => {
+            expect(parseGatewayArgs(["--max-concurrency", "4", "gemini", "--acp"])).toMatchObject({
+                maxConcurrency: 4,
+                rest: ["gemini", "--acp"],
+            });
+        });
+        it("should read the registry options", () => {
+            expect(parseGatewayArgs(["--agent", "gemini"])).toMatchObject({
+                agentId: "gemini",
+                command: "run",
+            });
+            expect(parseGatewayArgs(["--agent"]).agentId).toBeUndefined();
+            expect(parseGatewayArgs(["--list-agents"]).command).toBe("list-agents");
+            expect(parseGatewayArgs(["--allow-unverified-agent"]).allowUnverifiedAgent).toBe(true);
+            expect(parseGatewayArgs(["--registry-url", "http://localhost/registry.json"]).registryUrl).toBe("http://localhost/registry.json");
+            expect(parseGatewayArgs(["--registry-url"]).registryUrl).toBeUndefined();
+        });
+        it("should recognise both spellings of the help flag", () => {
+            expect(parseGatewayArgs(["--help"]).command).toBe("help");
+            expect(parseGatewayArgs(["-h"]).command).toBe("help");
+        });
+    });
+    describe("isRunnable", () => {
+        it("finds a command on PATH", () => {
+            expect(isRunnable("node", { PATH: process.env.PATH }, process.platform)).toBe(true);
+        });
+        it("does not find one that is not there", () => {
+            expect(isRunnable("acp-gateway-no-such-command", { PATH: process.env.PATH })).toBe(false);
+            expect(isRunnable("node", { PATH: "" })).toBe(false);
+            expect(isRunnable("node", {})).toBe(false);
+        });
+        it("checks a path directly rather than searching PATH", () => {
+            expect(isRunnable(process.execPath, {})).toBe(true);
+            expect(isRunnable("/no/such/agent", {})).toBe(false);
+        });
+        it("honours PATHEXT and backslashes on Windows", () => {
+            // A bare name on Windows resolves through PATHEXT, so "npx" alone finds
+            // nothing while "npx.cmd" would.
+            expect(isRunnable("npx", { PATH: "C:\\tools", PATHEXT: ".EXE" }, "win32")).toBe(false);
+            expect(isRunnable("C:\\nope\\agent.exe", {}, "win32")).toBe(false);
+        });
+    });
+    describe("assertAgentRunnable", () => {
+        it("accepts a command that exists", () => {
+            expect(() => assertAgentRunnable("node", false)).not.toThrow();
+        });
+        it("suggests --agent when the command looks like a registry id", () => {
+            expect(() => assertAgentRunnable("antigravity-acp", false)).toThrow(/run it with --agent antigravity-acp/);
+        });
+        it("blames the registry when the id was already resolved", () => {
+            expect(() => assertAgentRunnable("acp-gateway-no-such-runner", true)).toThrow(/The registry says to run it as "acp-gateway-no-such-runner", which is not installed/);
+        });
+    });
+    describe("runListAgents", () => {
+        const registry = {
+            version: "1.0.0",
+            agents: [
+                {
+                    id: "gemini",
+                    name: "Gemini CLI",
+                    version: "0.58.0",
+                    description: "Google's CLI",
+                    distribution: { npx: { package: "@google/gemini-cli", args: ["--acp"] } },
+                },
+            ],
+        };
+        it("should print every agent and how to run one", async () => {
+            const logSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+            const fetchImpl = vi.fn().mockResolvedValue({ ok: true, json: async () => registry });
+            await runListAgents(undefined, fetchImpl);
+            const printed = logSpy.mock.calls.flat().join("\n");
+            logSpy.mockRestore();
+            expect(printed).toContain("ACP registry v1.0.0 — 1 agents");
+            expect(printed).toContain("gemini");
+            expect(printed).toContain("acp-gateway --agent <id>");
+        });
+        it("should read a registry the user pointed it at", async () => {
+            const logSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+            const fetchImpl = vi.fn().mockResolvedValue({ ok: true, json: async () => registry });
+            await runListAgents("http://localhost/registry.json", fetchImpl);
+            logSpy.mockRestore();
+            expect(fetchImpl).toHaveBeenCalledWith("http://localhost/registry.json");
+        });
+    });
+    describe("resolveAgentCommand", () => {
+        const options = (overrides = {}) => ({
+            maxConcurrency: 2,
+            permissionTimeoutMs: 30 * 60_000,
+            command: "run",
+            allowUnverifiedAgent: false,
+            rest: [],
+            ...overrides,
+        });
+        it("should use the command given after -- when no registry id was named", async () => {
+            const fetchImpl = vi.fn();
+            const resolved = await resolveAgentCommand(options(), ["gemini", "--acp"], fetchImpl);
+            expect(resolved).toEqual({ command: ["gemini", "--acp"] });
+            expect(fetchImpl).not.toHaveBeenCalled();
+        });
+        it("should resolve a registry id into the command that runs it", async () => {
+            const errorSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+            const fetchImpl = vi.fn().mockResolvedValue({
+                ok: true,
+                json: async () => ({
+                    version: "1.0.0",
+                    agents: [
+                        {
+                            id: "gemini",
+                            name: "Gemini CLI",
+                            version: "0.58.0",
+                            description: "Google's CLI",
+                            distribution: {
+                                npx: { package: "@google/gemini-cli@0.58.0", args: ["--acp"], env: { K: "v" } },
+                            },
+                        },
+                    ],
+                }),
+            });
+            const resolved = await resolveAgentCommand(options({ agentId: "gemini" }), [], fetchImpl);
+            errorSpy.mockRestore();
+            expect(resolved.command[0]).toMatch(/^npx/);
+            expect(resolved.command.slice(1)).toEqual(["-y", "@google/gemini-cli@0.58.0", "--acp"]);
+            expect(resolved.env).toEqual({ K: "v" });
+        });
+        it("should surface a registry id that does not exist", async () => {
+            const fetchImpl = vi.fn().mockResolvedValue({
+                ok: true,
+                json: async () => ({ version: "1.0.0", agents: [] }),
+            });
+            await expect(resolveAgentCommand(options({ agentId: "nope" }), [], fetchImpl)).rejects.toThrow(/No agent "nope" in the ACP registry/);
+        });
+    });
+    describe("runAgentCommand", () => {
+        const agentrqConfig = { env: {} };
+        let logSpy;
+        let errorSpy;
+        function mockConnection(overrides, initResult = {}) {
+            const connection = {
+                initialize: vi.fn().mockResolvedValue({ protocolVersion: "0.1.0", ...initResult }),
+                ...overrides,
+            };
+            vi.mocked(acp.ClientSideConnection).mockImplementationOnce(function () {
+                return connection;
+            });
+            return connection;
+        }
+        beforeEach(() => {
+            spawnedAgents.length = 0;
+            logSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+            errorSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        });
+        it("should list the agent's login methods and shut the agent down again", async () => {
+            mockConnection({}, {
+                authMethods: [{ id: "agent-login", name: "Agent login" }],
+                agentCapabilities: { auth: { logout: {} } },
+            });
+            await runAgentCommand("list-auth-methods", ["gemini", "--acp"], agentrqConfig, fakeBridge());
+            const printed = logSpy.mock.calls.flat().join("\n");
+            expect(printed).toContain("Agent login (agent-login)");
+            expect(printed).toContain("--logout");
+            expect(spawnedAgents[0].kill).toHaveBeenCalled();
+        });
+        it("should print what the agent says it supports", async () => {
+            mockConnection({}, {
+                protocolVersion: 1,
+                agentCapabilities: {
+                    loadSession: true,
+                    sessionCapabilities: { resume: {} },
+                    mcpCapabilities: { http: true },
+                },
+            });
+            await runAgentCommand("agent-info", ["gemini", "--acp"], agentrqConfig, fakeBridge());
+            const printed = String(logSpy.mock.calls.at(-1)[0]);
+            expect(printed).toContain("gemini --acp");
+            expect(printed).toContain("ACP protocol version 1");
+            expect(printed).toContain("session/resume  yes");
+            expect(printed).toContain("session/close   no");
+            expect(printed).toContain("http  yes");
+            expect(spawnedAgents[0].kill).toHaveBeenCalled();
+        });
+        it("should report agents that advertise no login", async () => {
+            mockConnection({});
+            await runAgentCommand("list-auth-methods", ["gemini", "--acp"], agentrqConfig, fakeBridge());
+            expect(logSpy.mock.calls.flat().join("\n")).toContain("no authentication methods");
+        });
+        it("should log out", async () => {
+            const connection = mockConnection({ logout: vi.fn().mockResolvedValue({}) }, {
+                agentCapabilities: { auth: { logout: {} } },
+            });
+            await runAgentCommand("logout", ["gemini", "--acp"], agentrqConfig, fakeBridge());
+            expect(connection.logout).toHaveBeenCalledWith({});
+        });
+        it("should log in with the method the user named", async () => {
+            const connection = mockConnection({ authenticate: vi.fn().mockResolvedValue({}) }, {
+                authMethods: [
+                    { id: "agent-login", name: "Agent login" },
+                    { id: "oauth", name: "OAuth" },
+                ],
+            });
+            await runAgentCommand("login", ["gemini", "--acp"], agentrqConfig, fakeBridge(), "oauth");
+            expect(connection.authenticate).toHaveBeenCalledWith({ methodId: "oauth" });
+        });
+        it("should still shut the agent down when the login fails", async () => {
+            mockConnection({ authenticate: vi.fn() }, {
+                authMethods: [{ id: "agent-login", name: "Agent login" }],
+            });
+            await expect(runAgentCommand("login", ["gemini", "--acp"], agentrqConfig, fakeBridge(), "missing")).rejects.toThrow(/Unknown authentication method/);
+            expect(spawnedAgents[0].kill).toHaveBeenCalled();
+        });
+    });
+    describe("helpText", () => {
+        it("should explain every option the parser accepts", () => {
+            const text = helpText("9.9.9");
+            // Every documented flag must be one parseGatewayArgs actually handles,
+            // and every flag it handles must be documented.
+            const documented = [...text.matchAll(/^\s{2}(--[a-z-]+|-h)/gm)].map((m) => m[1]);
+            expect(new Set(documented)).toEqual(new Set([
+                "--agent",
+                "--list-agents",
+                "--agent-info",
+                "--allow-unverified-agent",
+                "--registry-url",
+                "--list-auth-methods",
+                "--login",
+                "--logout",
+                "--auth-method",
+                "--max-concurrency",
+                "--permission-timeout",
+                "--help",
+            ]));
+        });
+        it("should name the version and show how to run an agent both ways", () => {
+            const text = helpText("9.9.9");
+            expect(text).toContain("acp-gateway 9.9.9");
+            expect(text).toContain("acp-gateway --agent gemini");
+            expect(text).toContain("acp-gateway -- gemini --acp");
+            expect(text).toContain(".mcp.json");
+        });
+        it("should say why an unverified agent is not installed by default", () => {
+            expect(helpText()).toMatch(/no way to tell what was downloaded/);
+        });
+    });
+    describe("printHelp", () => {
+        it("should print the help text", () => {
+            const logSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+            printHelp();
+            const printed = logSpy.mock.calls.flat().join("\n");
+            logSpy.mockRestore();
+            expect(printed).toContain("USAGE");
+            expect(printed).toContain("--list-agents");
+        });
+    });
+    describe("authConfig", () => {
+        it("should start out with no preferred login method", () => {
+            expect(authConfig).toEqual({});
+        });
+    });
+    describe("isInteractiveTerminal", () => {
+        it("should be true only when both stdin and stderr are a TTY", () => {
+            const original = { stdin: process.stdin.isTTY, stderr: process.stderr.isTTY };
+            try {
+                process.stdin.isTTY = true;
+                process.stderr.isTTY = true;
+                expect(isInteractiveTerminal()).toBe(true);
+                process.stderr.isTTY = false;
+                expect(isInteractiveTerminal()).toBe(false);
+            }
+            finally {
+                process.stdin.isTTY = original.stdin;
+                process.stderr.isTTY = original.stderr;
+            }
+        });
     });
     describe("pickHumanApprovalMode", () => {
         // The real modes codex-acp advertises. Its default is "agent", whose
@@ -482,5 +955,64 @@ describe("index", () => {
             expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to set session mode"), expect.any(Error));
         });
     });
+    describe("handleAgentModeChange", () => {
+        const modes = {
+            currentModeId: "ask",
+            availableModes: [
+                { id: "ask", name: "Ask first" },
+                { id: "auto", name: "Auto approve" },
+            ],
+        };
+        let errorSpy;
+        beforeEach(() => {
+            errorSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        });
+        afterEach(() => errorSpy.mockRestore());
+        it("should leave a mode that still asks the human alone", async () => {
+            const connection = { setSessionMode: vi.fn() };
+            await handleAgentModeChange(connection, "sess-ok", "ask", modes);
+            expect(connection.setSessionMode).not.toHaveBeenCalled();
+        });
+        it("should put the session back when the agent starts approving for us", async () => {
+            const connection = { setSessionMode: vi.fn().mockResolvedValue({}) };
+            await handleAgentModeChange(connection, "sess-drift", "auto", modes);
+            expect(connection.setSessionMode).toHaveBeenCalledWith({
+                sessionId: "sess-drift",
+                modeId: "ask",
+            });
+        });
+        it("should treat a mode the agent never advertised as untrusted", async () => {
+            const connection = { setSessionMode: vi.fn().mockResolvedValue({}) };
+            await handleAgentModeChange(connection, "sess-unknown", "something-new", modes);
+            expect(connection.setSessionMode).toHaveBeenCalledWith({
+                sessionId: "sess-unknown",
+                modeId: "ask",
+            });
+        });
+        it("should stop fighting an agent that keeps switching back", async () => {
+            const connection = { setSessionMode: vi.fn().mockResolvedValue({}) };
+            for (let i = 0; i < 5; i++) {
+                await handleAgentModeChange(connection, "sess-stubborn", "auto", modes);
+            }
+            // An unbounded fight would be an endless stream of setSessionMode calls.
+            expect(connection.setSessionMode).toHaveBeenCalledTimes(3);
+            expect(errorSpy.mock.calls.flat().join("\n")).toContain("Giving up after 3 attempts");
+        });
+        it("should start counting again once the session is back in a safe mode", async () => {
+            const connection = { setSessionMode: vi.fn().mockResolvedValue({}) };
+            await handleAgentModeChange(connection, "sess-recovered", "auto", modes);
+            await handleAgentModeChange(connection, "sess-recovered", "ask", modes);
+            for (let i = 0; i < 4; i++) {
+                await handleAgentModeChange(connection, "sess-recovered", "auto", modes);
+            }
+            expect(connection.setSessionMode).toHaveBeenCalledTimes(4);
+        });
+        it("should do nothing for an agent that offers no modes at all", async () => {
+            const connection = { setSessionMode: vi.fn() };
+            await handleAgentModeChange(connection, "sess-modeless", "whatever", undefined);
+            await handleAgentModeChange(connection, "sess-modeless", "whatever", { availableModes: [] });
+            expect(connection.setSessionMode).not.toHaveBeenCalled();
+        });
+    });
 });
 //# sourceMappingURL=index.test.js.map