@agentrq/acp-gateway 0.2.4 → 0.2.6

package/dist/__tests__/index.test.js

@@ -1,7 +1,17 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
+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, runAuthCommand, } from "../index.js";
+import { createAcpSessionSwitcher, checkForNextTask, mapMcpServers, TaskQueue, getOrCreateSession, activeSessions, authConfig, createSessionWithAuth, isInteractiveTerminal, openAgentConnection, parseGatewayArgs, assertAgentRunnable, helpText, isRunnable, printHelp, resolveAgentCommand, runListAgents, pickHumanApprovalMode, enforceHumanApprovalMode, handleAgentModeChange, runAgentCommand, findActiveSession, handleTaskCancellation, cancelledTaskSeq, markTaskCancelled, isTaskCancelled, nextTaskSeq, } 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 () => {
@@ -66,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",
@@ -328,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);
@@ -337,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);
@@ -345,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);
@@ -356,7 +404,7 @@ describe("index", () => {
             }));
         });
         it("should declare whether it can host a terminal login", async () => {
-            const mockBridge = {};
+            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({
@@ -381,13 +429,13 @@ describe("index", () => {
                     prompt: vi.fn(),
                 };
             });
-            const session = await getOrCreateSession("T-Login", ["node", "agent.js"], [], { env: {} }, {});
+            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 = {};
+            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);
@@ -411,7 +459,7 @@ describe("index", () => {
             const onExit = vi.fn();
             const agent = await openAgentConnection({
                 acpCmdArgs: ["node", "agent.js"],
-                mcpBridge: {},
+                mcpBridge: fakeBridge(),
                 label: "login",
                 onExit,
             });
@@ -450,11 +498,22 @@ describe("index", () => {
         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);
@@ -577,6 +636,7 @@ describe("index", () => {
     describe("resolveAgentCommand", () => {
         const options = (overrides = {}) => ({
             maxConcurrency: 2,
+            permissionTimeoutMs: 30 * 60_000,
             command: "run",
             allowUnverifiedAgent: false,
             rest: [],
@@ -621,7 +681,7 @@ describe("index", () => {
             await expect(resolveAgentCommand(options({ agentId: "nope" }), [], fetchImpl)).rejects.toThrow(/No agent "nope" in the ACP registry/);
         });
     });
-    describe("runAuthCommand", () => {
+    describe("runAgentCommand", () => {
         const agentrqConfig = { env: {} };
         let logSpy;
         let errorSpy;
@@ -645,22 +705,40 @@ describe("index", () => {
                 authMethods: [{ id: "agent-login", name: "Agent login" }],
                 agentCapabilities: { auth: { logout: {} } },
             });
-            await runAuthCommand("list-auth-methods", ["gemini", "--acp"], agentrqConfig, {});
+            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 runAuthCommand("list-auth-methods", ["gemini", "--acp"], agentrqConfig, {});
+            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 runAuthCommand("logout", ["gemini", "--acp"], agentrqConfig, {});
+            await runAgentCommand("logout", ["gemini", "--acp"], agentrqConfig, fakeBridge());
             expect(connection.logout).toHaveBeenCalledWith({});
         });
         it("should log in with the method the user named", async () => {
@@ -670,14 +748,14 @@ describe("index", () => {
                     { id: "oauth", name: "OAuth" },
                 ],
             });
-            await runAuthCommand("login", ["gemini", "--acp"], agentrqConfig, {}, "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(runAuthCommand("login", ["gemini", "--acp"], agentrqConfig, {}, "missing")).rejects.toThrow(/Unknown authentication method/);
+            await expect(runAgentCommand("login", ["gemini", "--acp"], agentrqConfig, fakeBridge(), "missing")).rejects.toThrow(/Unknown authentication method/);
             expect(spawnedAgents[0].kill).toHaveBeenCalled();
         });
     });
@@ -690,6 +768,7 @@ describe("index", () => {
             expect(new Set(documented)).toEqual(new Set([
                 "--agent",
                 "--list-agents",
+                "--agent-info",
                 "--allow-unverified-agent",
                 "--registry-url",
                 "--list-auth-methods",
@@ -697,6 +776,7 @@ describe("index", () => {
                 "--logout",
                 "--auth-method",
                 "--max-concurrency",
+                "--permission-timeout",
                 "--help",
             ]));
         });
@@ -875,5 +955,193 @@ describe("index", () => {
             expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to set session mode"), expect.any(Error));
         });
     });
+    describe("task cancellation handling", () => {
+        let errorSpy;
+        beforeEach(() => {
+            activeSessions.clear();
+            errorSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        });
+        afterEach(() => {
+            activeSessions.clear();
+            errorSpy.mockRestore();
+        });
+        describe("findActiveSession", () => {
+            it("should find session by direct task key", () => {
+                const mockSession = { sessionId: "sess-1", acpClient: { cancelTurn: vi.fn() } };
+                activeSessions.set("task-1", mockSession);
+                expect(findActiveSession("task-1")).toBe(mockSession);
+            });
+            it("should find session by sessionId match", () => {
+                const mockSession = { sessionId: "sess-custom", acpClient: { cancelTurn: vi.fn() } };
+                activeSessions.set("key-other", mockSession);
+                expect(findActiveSession("sess-custom")).toBe(mockSession);
+            });
+            it("should return the single session if no taskId is provided", () => {
+                const mockSession = { sessionId: "sess-only", acpClient: { cancelTurn: vi.fn() } };
+                activeSessions.set("default", mockSession);
+                expect(findActiveSession(undefined)).toBe(mockSession);
+            });
+            it("should fallback to default keyed session when taskId is given but only 1 session exists", () => {
+                const mockSession = { sessionId: "s1", acpClient: { cancelTurn: vi.fn() } };
+                activeSessions.set("default", mockSession);
+                expect(findActiveSession("task-new-id")).toBe(mockSession);
+            });
+            it("should not fall back to a session that belongs to a different task", () => {
+                // Task A is running; a cancel for queued task B must not abort it.
+                const sessionA = { sessionId: "sess-a", acpClient: { cancelTurn: vi.fn() } };
+                activeSessions.set("task-a", sessionA);
+                expect(findActiveSession("task-b")).toBeUndefined();
+            });
+            it("should return undefined if taskId is not found when multiple sessions exist", () => {
+                activeSessions.set("task-1", { sessionId: "s1" });
+                activeSessions.set("task-2", { sessionId: "s2" });
+                expect(findActiveSession("task-nonexistent")).toBeUndefined();
+                expect(findActiveSession(undefined)).toBeUndefined();
+            });
+        });
+        describe("handleTaskCancellation", () => {
+            it("should cancel turn on the matched active session", async () => {
+                const cancelTurn = vi.fn().mockResolvedValue(undefined);
+                const mockSession = {
+                    sessionId: "sess-100",
+                    acpClient: { cancelTurn },
+                };
+                activeSessions.set("task-100", mockSession);
+                await handleTaskCancellation("task-100", "cancelled by user");
+                expect(cancelTurn).toHaveBeenCalledWith("sess-100");
+                expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining("Cancelling session sess-100 for task task-100 (cancelled by user)"));
+            });
+            it("should skip a task cancelled while it was still being fetched", async () => {
+                cancelledTaskSeq.clear();
+                const promptMock = vi.fn();
+                const switcher = { ensureForTask: vi.fn().mockResolvedValue("s-q1") };
+                const acpClient = { flushReply: vi.fn(), reportStopReason: vi.fn() };
+                const connection = { prompt: promptMock };
+                const bridge = {
+                    // The cancel lands while the poll is in flight — the task has no
+                    // session yet, so nothing but this flag can stop it.
+                    callTool: vi.fn().mockImplementation(async () => {
+                        await handleTaskCancellation("task-queued-1");
+                        return { content: [{ type: "text", text: "task task-queued-1: do work" }] };
+                    }),
+                };
+                await checkForNextTask(bridge, connection, switcher, acpClient);
+                expect(promptMock).not.toHaveBeenCalled();
+            });
+            it("should not swallow work queued after the cancellation", async () => {
+                // agentrq reuses a chat's id as the task id, so the id cancelled a
+                // moment ago is the same id the user's next message arrives under.
+                cancelledTaskSeq.clear();
+                await handleTaskCancellation("task-queued-2");
+                const promptMock = vi.fn().mockResolvedValue({ stopReason: "end_turn" });
+                const switcher = { ensureForTask: vi.fn().mockResolvedValue("s-q2") };
+                const acpClient = { flushReply: vi.fn(), reportStopReason: vi.fn() };
+                const connection = { prompt: promptMock };
+                const bridge = {
+                    callTool: vi.fn().mockResolvedValue({
+                        content: [{ type: "text", text: "task task-queued-2: fresh work" }],
+                    }),
+                };
+                await checkForNextTask(bridge, connection, switcher, acpClient);
+                expect(promptMock).toHaveBeenCalled();
+            });
+            it("should forget the oldest cancellations rather than grow forever", async () => {
+                cancelledTaskSeq.clear();
+                for (let i = 0; i < 250; i++)
+                    markTaskCancelled(`task-${i}`);
+                expect(cancelledTaskSeq.size).toBe(200);
+                expect(cancelledTaskSeq.has("task-0")).toBe(false);
+                expect(cancelledTaskSeq.has("task-249")).toBe(true);
+            });
+            it("should only stop the notification that was queued before the cancel", async () => {
+                cancelledTaskSeq.clear();
+                const older = nextTaskSeq();
+                await handleTaskCancellation("task-two-turns");
+                const newer = nextTaskSeq();
+                expect(isTaskCancelled("task-two-turns", older)).toBe(true);
+                expect(isTaskCancelled("task-two-turns", newer)).toBe(false);
+            });
+            it("should log when task to cancel is not found", async () => {
+                await handleTaskCancellation("task-missing");
+                expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining("Received cancellation for task task-missing, but no active session found"));
+            });
+            it("should cancel the single session when taskId is omitted and only 1 session exists", async () => {
+                const cancel1 = vi.fn().mockResolvedValue(undefined);
+                activeSessions.set("t1", { sessionId: "s1", acpClient: { cancelTurn: cancel1 } });
+                await handleTaskCancellation(undefined, "single shutdown");
+                expect(cancel1).toHaveBeenCalledWith("s1");
+                expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining("Received cancellation with no taskId (single shutdown). Cancelling active session s1..."));
+            });
+            it("should fail closed and not cancel anything when taskId is omitted and multiple sessions exist", async () => {
+                const cancel1 = vi.fn().mockResolvedValue(undefined);
+                const cancel2 = vi.fn().mockResolvedValue(undefined);
+                activeSessions.set("t1", { sessionId: "s1", acpClient: { cancelTurn: cancel1 } });
+                activeSessions.set("t2", { sessionId: "s2", acpClient: { cancelTurn: cancel2 } });
+                await handleTaskCancellation(undefined, "multiple active");
+                expect(cancel1).not.toHaveBeenCalled();
+                expect(cancel2).not.toHaveBeenCalled();
+                expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining("but 2 sessions are active (skipping to avoid aborting unrelated tasks)"));
+            });
+        });
+    });
+    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