@agentrq/acp-gateway 0.2.8 → 0.2.10

package/dist/__tests__/index.test.js

@@ -1,7 +1,10 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 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, findActiveSession, handleTaskCancellation, cancelledTaskSeq, markTaskCancelled, isTaskCancelled, nextTaskSeq, supportsCloseSession, closeSession, closeAllSessions, setupSignalHandlers, } from "../index.js";
+import { createAcpSessionSwitcher, checkForNextTask, mapMcpServers, TaskQueue, getOrCreateSession, activeSessions, authConfig, modelConfig, createSessionWithAuth, isInteractiveTerminal, openAgentConnection, parseGatewayArgs, assertAgentRunnable, helpText, isRunnable, resolveOnPath, spawnTarget, needsShell, escapeCmdCommand, quoteForCmd, spawnArgsFor, terminateAgentProcess, printHelp, resolveAgentCommand, runListAgents, pickHumanApprovalMode, enforceHumanApprovalMode, handleAgentModeChange, runAgentCommand, findActiveSession, handleTaskCancellation, cancelledTaskSeq, markTaskCancelled, isTaskCancelled, nextTaskSeq, supportsCloseSession, closeSession, closeAllSessions, setupSignalHandlers, } from "../index.js";
 import { AUTH_REQUIRED_CODE } from "../auth.js";
 /**
  * A stand-in for the workspace bridge.
@@ -10,7 +13,10 @@ import { AUTH_REQUIRED_CODE } from "../auth.js";
  * a bare object is not enough — the real bridge is an EventEmitter.
  */
 function fakeBridge() {
-    return new EventEmitter();
+    const emitter = new EventEmitter();
+    emitter.sendNotification = vi.fn().mockResolvedValue(undefined);
+    emitter.callTool = vi.fn().mockResolvedValue({ isError: false, content: [] });
+    return emitter;
 }
 // Real emitters so the agent-process lifecycle handlers can be exercised.
 const { spawnedAgents } = vi.hoisted(() => ({ spawnedAgents: [] }));
@@ -457,6 +463,58 @@ describe("index", () => {
             expect(newSession).toHaveBeenCalledTimes(2);
             expect(session.sessionId).toBe("authed-sess");
         });
+        it("should forward models to workspace on session creation and set model if configured", async () => {
+            const mockBridge = fakeBridge();
+            const setSessionConfigOption = vi.fn().mockResolvedValue({
+                configOptions: [
+                    {
+                        id: "model",
+                        name: "Model",
+                        type: "select",
+                        currentValue: "gpt-4o",
+                        options: [
+                            { value: "gpt-4", name: "GPT-4" },
+                            { value: "gpt-4o", name: "GPT-4o" },
+                        ],
+                    },
+                ],
+            });
+            vi.mocked(acp.ClientSideConnection).mockImplementationOnce(function () {
+                return {
+                    initialize: vi.fn().mockResolvedValue({ protocolVersion: "0.1.0" }),
+                    newSession: vi.fn().mockResolvedValue({
+                        sessionId: "model-sess",
+                        configOptions: [
+                            {
+                                id: "model",
+                                name: "Model",
+                                type: "select",
+                                currentValue: "gpt-4",
+                                options: [
+                                    { value: "gpt-4", name: "GPT-4" },
+                                    { value: "gpt-4o", name: "GPT-4o" },
+                                ],
+                            },
+                        ],
+                    }),
+                    setSessionConfigOption,
+                    prompt: vi.fn(),
+                };
+            });
+            modelConfig.modelId = "gpt-4o";
+            const session = await getOrCreateSession("T-Model", ["node", "agent.js"], [], { env: {} }, mockBridge);
+            expect(setSessionConfigOption).toHaveBeenCalledWith({
+                sessionId: "model-sess",
+                configId: "model",
+                value: "gpt-4o",
+            });
+            expect(mockBridge.sendNotification).toHaveBeenCalledWith("notifications/claude/channel/models", expect.objectContaining({
+                task_id: "T-Model",
+                session_id: "model-sess",
+                current_model: "gpt-4o",
+            }));
+            modelConfig.modelId = undefined;
+        });
         it("should drop the cached session when the agent process dies", async () => {
             const mockBridge = fakeBridge();
             await getOrCreateSession("T-Exit", ["node", "agent.js"], [], { env: {} }, mockBridge);
@@ -493,6 +551,38 @@ describe("index", () => {
                 }),
             }));
         });
+        it("spawns an ordinary agent command directly", async () => {
+            const { spawn } = await import("node:child_process");
+            await openAgentConnection({
+                acpCmdArgs: ["node", "agent.js"],
+                mcpBridge: fakeBridge(),
+                label: "spawn-plain",
+            });
+            expect(vi.mocked(spawn)).toHaveBeenLastCalledWith("node", ["agent.js"], expect.objectContaining({ shell: false }));
+        });
+        it("resolves npx on Windows and spawns the batch file through a shell", async () => {
+            // The whole reported failure in one test: the registry says "npx", the
+            // machine has it as npx.cmd, and a batch file needs a shell to start.
+            const { spawn } = await import("node:child_process");
+            const dir = mkdtempSync(join(tmpdir(), "acp-gateway-path-"));
+            writeFileSync(join(dir, "npx.cmd"), "");
+            const platform = process.platform;
+            Object.defineProperty(process, "platform", { value: "win32", configurable: true });
+            vi.stubEnv("PATH", dir);
+            vi.stubEnv("PATHEXT", ".EXE;.cmd");
+            try {
+                await openAgentConnection({
+                    acpCmdArgs: ["npx", "-y", "@zed-industries/codex-acp"],
+                    mcpBridge: fakeBridge(),
+                    label: "spawn-windows",
+                });
+            }
+            finally {
+                Object.defineProperty(process, "platform", { value: platform, configurable: true });
+                vi.unstubAllEnvs();
+            }
+            expect(vi.mocked(spawn)).toHaveBeenLastCalledWith(join(dir, "npx.cmd"), ['^"-y^"', '^"@zed-industries/codex-acp^"'], expect.objectContaining({ shell: true }));
+        });
         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 () {
@@ -613,6 +703,14 @@ describe("index", () => {
             expect(parseGatewayArgs(["--registry-url", "http://localhost/registry.json"]).registryUrl).toBe("http://localhost/registry.json");
             expect(parseGatewayArgs(["--registry-url"]).registryUrl).toBeUndefined();
         });
+        it("should recognise model options", () => {
+            expect(parseGatewayArgs(["--list-models"])).toMatchObject({ command: "list-models" });
+            expect(parseGatewayArgs(["--model", "claude-3-7-sonnet"])).toMatchObject({
+                command: "run",
+                modelId: "claude-3-7-sonnet",
+            });
+            expect(parseGatewayArgs(["--model"]).modelId).toBeUndefined();
+        });
         it("should recognise both spellings of the help flag", () => {
             expect(parseGatewayArgs(["--help"]).command).toBe("help");
             expect(parseGatewayArgs(["-h"]).command).toBe("help");
@@ -637,6 +735,160 @@ describe("index", () => {
             expect(isRunnable("npx", { PATH: "C:\\tools", PATHEXT: ".EXE" }, "win32")).toBe(false);
             expect(isRunnable("C:\\nope\\agent.exe", {}, "win32")).toBe(false);
         });
+        it("finds a Windows command that already carries its suffix", () => {
+            // The registry launches npm agents as "npx.cmd"; appending PATHEXT to
+            // that would only ever look for "npx.cmd.EXE" and friends.
+            const dir = mkdtempSync(join(tmpdir(), "acp-gateway-path-"));
+            writeFileSync(join(dir, "npx.cmd"), "");
+            expect(isRunnable("npx.cmd", { PATH: dir, PATHEXT: ".COM;.EXE;.BAT;.CMD" }, "win32")).toBe(true);
+            expect(isRunnable("npx.cmd", { PATH: dir }, "win32")).toBe(true);
+            // A suffix PATHEXT does not list is still a bare name to complete.
+            expect(isRunnable("npx.cmd", { PATH: dir, PATHEXT: ".EXE" }, "win32")).toBe(false);
+        });
+        it("still completes a bare Windows name from PATHEXT", () => {
+            const dir = mkdtempSync(join(tmpdir(), "acp-gateway-path-"));
+            writeFileSync(join(dir, "agent.CMD"), "");
+            expect(isRunnable("agent", { PATH: dir, PATHEXT: ".EXE;.CMD" }, "win32")).toBe(true);
+            expect(isRunnable("agent", { PATH: dir, PATHEXT: ".EXE" }, "win32")).toBe(false);
+        });
+    });
+    describe("resolveOnPath", () => {
+        it("returns the file a name resolves to", () => {
+            const dir = mkdtempSync(join(tmpdir(), "acp-gateway-path-"));
+            writeFileSync(join(dir, "npx.cmd"), "");
+            expect(resolveOnPath("npx", { PATH: dir, PATHEXT: ".EXE;.cmd" }, "win32")).toBe(join(dir, "npx.cmd"));
+            expect(resolveOnPath("npx", { PATH: dir, PATHEXT: ".EXE" }, "win32")).toBeUndefined();
+        });
+        it("takes the first directory on PATH that has it", () => {
+            const first = mkdtempSync(join(tmpdir(), "acp-gateway-path-"));
+            const second = mkdtempSync(join(tmpdir(), "acp-gateway-path-"));
+            writeFileSync(join(first, "agent.exe"), "");
+            writeFileSync(join(second, "agent.exe"), "");
+            expect(resolveOnPath("agent", { PATH: `${first};${second}`, PATHEXT: ".exe" }, "win32")).toBe(join(first, "agent.exe"));
+        });
+    });
+    describe("spawnTarget", () => {
+        it("leaves a command alone off Windows", () => {
+            expect(spawnTarget("npx", { PATH: "/usr/bin" }, "darwin")).toBe("npx");
+        });
+        it("resolves the suffix a Windows runner is actually installed under", () => {
+            // A stock npm install ships npx.cmd, a Volta install ships npx.exe, and
+            // only one of those needs a shell to start.
+            const batch = mkdtempSync(join(tmpdir(), "acp-gateway-path-"));
+            writeFileSync(join(batch, "npx.cmd"), "");
+            expect(spawnTarget("npx", { PATH: batch, PATHEXT: ".exe;.cmd" }, "win32")).toBe(join(batch, "npx.cmd"));
+            const shimmed = mkdtempSync(join(tmpdir(), "acp-gateway-path-"));
+            writeFileSync(join(shimmed, "npx.exe"), "");
+            const resolved = spawnTarget("npx", { PATH: shimmed, PATHEXT: ".exe;.cmd" }, "win32");
+            expect(resolved).toBe(join(shimmed, "npx.exe"));
+            expect(needsShell(resolved, "win32")).toBe(false);
+        });
+        it("falls back to the name when nothing on PATH matches", () => {
+            expect(spawnTarget("npx", { PATH: "C:\\nowhere", PATHEXT: ".EXE" }, "win32")).toBe("npx");
+            expect(spawnTarget("C:\\tools\\agent.cmd", { PATH: "" }, "win32")).toBe("C:\\tools\\agent.cmd");
+        });
+    });
+    describe("needsShell", () => {
+        it("asks for a shell only for Windows batch files", () => {
+            expect(needsShell("npx.cmd", "win32")).toBe(true);
+            expect(needsShell("C:\\tools\\Agent.BAT", "win32")).toBe(true);
+            expect(needsShell("node.exe", "win32")).toBe(false);
+            expect(needsShell("npx", "win32")).toBe(false);
+        });
+        it("never asks for one off Windows", () => {
+            expect(needsShell("npx.cmd", "darwin")).toBe(false);
+            expect(needsShell("npx", "linux")).toBe(false);
+        });
+    });
+    describe("escapeCmdCommand", () => {
+        it("leaves a plain program name alone", () => {
+            expect(escapeCmdCommand("npx.cmd")).toBe("npx.cmd");
+        });
+        it("escapes what cmd.exe would otherwise act on", () => {
+            // The space is escaped rather than quoted, so cmd.exe reads the whole
+            // path as the program name.
+            expect(escapeCmdCommand("C:\\Program Files\\nodejs\\npx.cmd")).toBe("C:\\Program^ Files\\nodejs\\npx.cmd");
+            expect(escapeCmdCommand("a&b.cmd")).toBe("a^&b.cmd");
+        });
+    });
+    describe("quoteForCmd", () => {
+        it("quotes every argument for both parsers", () => {
+            // Quoted for the agent's own argument parser, then escaped so cmd.exe
+            // passes those quotes along instead of eating them.
+            expect(quoteForCmd("-y")).toBe('^"-y^"');
+            expect(quoteForCmd("@zed-industries/codex-acp")).toBe('^"@zed-industries/codex-acp^"');
+            expect(quoteForCmd("")).toBe('^"^"');
+        });
+        it("neutralises whitespace and shell syntax", () => {
+            expect(quoteForCmd("two words")).toBe('^"two^ words^"');
+            expect(quoteForCmd("a&b|c")).toBe('^"a^&b^|c^"');
+            expect(quoteForCmd("%PATH%")).toBe('^"^%PATH^%^"');
+        });
+        it("escapes twice for a wrapper that re-enters cmd.exe", () => {
+            expect(quoteForCmd("a&b", true)).toBe('^^^"a^^^&b^^^"');
+        });
+        it("doubles the backslashes a quote would otherwise escape", () => {
+            expect(quoteForCmd('say "hi"')).toBe('^"say^ \\^"hi\\^"^"');
+            expect(quoteForCmd("C:\\dir\\")).toBe('^"C:\\dir\\\\^"');
+            // A run of backslashes before a quote is doubled whole, then the quote
+            // gets its own: two backslashes and a quote need five and a quote.
+            expect(quoteForCmd('a\\\\"b')).toBe('^"a\\\\\\\\\\^"b^"');
+        });
+    });
+    describe("spawnArgsFor", () => {
+        it("passes the command through when no shell is involved", () => {
+            expect(spawnArgsFor("npx", ["-y", "some pkg"], "darwin")).toEqual([
+                "npx",
+                ["-y", "some pkg"],
+            ]);
+            expect(spawnArgsFor("npx.cmd", ["-y", "codex-acp"], "linux")).toEqual([
+                "npx.cmd",
+                ["-y", "codex-acp"],
+            ]);
+        });
+        it("escapes twice for an npm bin shim, which re-enters cmd.exe", () => {
+            expect(spawnArgsFor("C:\\proj\\node_modules\\.bin\\my-agent.cmd", ["--flag"], "win32")).toEqual(["C:\\proj\\node_modules\\.bin\\my-agent.cmd", ['^^^"--flag^^^"']]);
+        });
+        it("escapes the command line a Windows shell would re-parse", () => {
+            expect(spawnArgsFor("C:\\Program Files\\nodejs\\npx.cmd", ["-y", "codex-acp"], "win32")).toEqual([
+                "C:\\Program^ Files\\nodejs\\npx.cmd",
+                ['^"-y^"', '^"codex-acp^"'],
+            ]);
+        });
+    });
+    describe("terminateAgentProcess", () => {
+        it("just kills the process off Windows", () => {
+            const child = { pid: 42, kill: vi.fn() };
+            const spawnImpl = vi.fn();
+            terminateAgentProcess(child, "darwin", spawnImpl);
+            expect(child.kill).toHaveBeenCalled();
+            expect(spawnImpl).not.toHaveBeenCalled();
+        });
+        it("kills the whole tree on Windows", () => {
+            const killer = new EventEmitter();
+            killer.unref = vi.fn();
+            const spawnImpl = vi.fn(() => killer);
+            const child = { pid: 4242, kill: vi.fn() };
+            terminateAgentProcess(child, "win32", spawnImpl);
+            expect(spawnImpl).toHaveBeenCalledWith("taskkill", ["/pid", "4242", "/T", "/F"], { stdio: "ignore" });
+            expect(killer.unref).toHaveBeenCalled();
+            expect(child.kill).not.toHaveBeenCalled();
+            // taskkill itself failing must not leave the agent running.
+            killer.emit("error", new Error("not found"));
+            expect(child.kill).toHaveBeenCalled();
+        });
+        it("falls back to a plain kill when the process has no pid", () => {
+            const child = { kill: vi.fn() };
+            const spawnImpl = vi.fn();
+            terminateAgentProcess(child, "win32", spawnImpl);
+            expect(child.kill).toHaveBeenCalled();
+            expect(spawnImpl).not.toHaveBeenCalled();
+        });
+        it("does nothing when there is no process to end", () => {
+            const spawnImpl = vi.fn();
+            expect(() => terminateAgentProcess(undefined, "win32", spawnImpl)).not.toThrow();
+            expect(spawnImpl).not.toHaveBeenCalled();
+        });
     });
     describe("assertAgentRunnable", () => {
         it("accepts a command that exists", () => {
@@ -758,6 +1010,60 @@ describe("index", () => {
             expect(printed).toContain("--logout");
             expect(spawnedAgents[0].kill).toHaveBeenCalled();
         });
+        it("should list models from configOptions and cleanly close session", async () => {
+            mockConnection({
+                newSession: vi.fn().mockResolvedValue({
+                    sessionId: "m-sess",
+                    configOptions: [
+                        {
+                            id: "model",
+                            name: "Model",
+                            type: "select",
+                            currentValue: "claude-3-7-sonnet",
+                            options: [
+                                { value: "claude-3-7-sonnet", name: "Claude 3.7 Sonnet" },
+                                { value: "claude-3-5-haiku", name: "Claude 3.5 Haiku" },
+                            ],
+                        },
+                    ],
+                }),
+            });
+            await runAgentCommand("list-models", ["gemini", "--acp"], agentrqConfig, fakeBridge());
+            const printed = logSpy.mock.calls.flat().join("\n");
+            expect(printed).toContain("Models supported by \"gemini --acp\":");
+            expect(printed).toContain("claude-3-7-sonnet");
+            expect(printed).toContain("Claude 3.7 Sonnet");
+            expect(spawnedAgents[0].kill).toHaveBeenCalled();
+        });
+        it("should list models from unstable_listProviders fallback", async () => {
+            mockConnection({
+                newSession: vi.fn().mockResolvedValue({ sessionId: "m-sess", configOptions: [] }),
+                unstable_listProviders: vi.fn().mockResolvedValue({
+                    providers: [
+                        {
+                            providerId: "anthropic",
+                            supported: ["claude-sonnet"],
+                        },
+                    ],
+                }),
+            }, {
+                agentCapabilities: { providers: true },
+            });
+            await runAgentCommand("list-models", ["gemini", "--acp"], agentrqConfig, fakeBridge());
+            const printed = logSpy.mock.calls.flat().join("\n");
+            expect(printed).toContain("Configurable providers for \"gemini --acp\":");
+            expect(printed).toContain("claude-sonnet");
+            expect(spawnedAgents[0].kill).toHaveBeenCalled();
+        });
+        it("should report when agent advertises no models", async () => {
+            mockConnection({
+                newSession: vi.fn().mockResolvedValue({ sessionId: "m-sess", configOptions: [] }),
+            });
+            await runAgentCommand("list-models", ["gemini", "--acp"], agentrqConfig, fakeBridge());
+            const printed = logSpy.mock.calls.flat().join("\n");
+            expect(printed).toContain("No configurable models advertised by \"gemini --acp\".");
+            expect(spawnedAgents[0].kill).toHaveBeenCalled();
+        });
         it("should print what the agent says it supports", async () => {
             mockConnection({}, {
                 protocolVersion: 1,
@@ -818,6 +1124,8 @@ describe("index", () => {
                 "--agent-info",
                 "--allow-unverified-agent",
                 "--registry-url",
+                "--list-models",
+                "--model",
                 "--list-auth-methods",
                 "--login",
                 "--logout",