@elvatis_com/openclaw-cli-bridge-elvatis 1.9.0 → 2.0.0

package/test/proxy-e2e.test.ts

@@ -12,10 +12,54 @@
  * routeToCliRunner is mocked so we don't need real CLIs installed.
  */
 
-import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
+import { describe, it, expect, beforeAll, afterAll, vi, beforeEach } from "vitest";
 import http from "node:http";
 import { startProxyServer, CLI_MODELS } from "../src/proxy-server.js";
 
+// Mock session-manager so we don't spawn real CLIs for session endpoints
+const mockSessions = new Map<string, { model: string; status: string; stdout: string; stderr: string; exitCode: number | null; startTime: number }>();
+let nextSessionId = "aabbccdd11223344";
+
+vi.mock("../src/session-manager.js", () => ({
+  sessionManager: {
+    spawn: vi.fn((model: string, _messages: unknown[]) => {
+      const id = nextSessionId;
+      mockSessions.set(id, { model, status: "running", stdout: "", stderr: "", exitCode: null, startTime: Date.now() });
+      // Generate a different ID next time
+      nextSessionId = Math.random().toString(16).slice(2, 18).padEnd(16, "0");
+      return id;
+    }),
+    poll: vi.fn((sessionId: string) => {
+      const entry = mockSessions.get(sessionId);
+      if (!entry) return null;
+      return { running: entry.status === "running", exitCode: entry.exitCode, status: entry.status };
+    }),
+    log: vi.fn((sessionId: string, offset = 0) => {
+      const entry = mockSessions.get(sessionId);
+      if (!entry) return null;
+      return { stdout: entry.stdout.slice(offset), stderr: entry.stderr.slice(offset), offset: entry.stdout.length };
+    }),
+    write: vi.fn((sessionId: string) => {
+      return mockSessions.has(sessionId);
+    }),
+    kill: vi.fn((sessionId: string) => {
+      const entry = mockSessions.get(sessionId);
+      if (!entry || entry.status !== "running") return false;
+      entry.status = "killed";
+      return true;
+    }),
+    list: vi.fn(() => {
+      const result: { sessionId: string; model: string; status: string; startTime: number; exitCode: number | null }[] = [];
+      for (const [sessionId, entry] of mockSessions) {
+        result.push({ sessionId, model: entry.model, status: entry.status, startTime: entry.startTime, exitCode: entry.exitCode });
+      }
+      return result;
+    }),
+    stop: vi.fn(),
+    cleanup: vi.fn(),
+  },
+}));
+
 // Mock cli-runner so we don't spawn real CLIs
 vi.mock("../src/cli-runner.js", async (importOriginal) => {
   const orig = await importOriginal<typeof import("../src/cli-runner.js")>();
@@ -24,7 +68,7 @@ vi.mock("../src/cli-runner.js", async (importOriginal) => {
     routeToCliRunner: vi.fn(async (model: string, _messages: unknown[], _timeout: number) => {
       // Simulate the real router: strip vllm/ prefix, validate model
       const normalized = model.startsWith("vllm/") ? model.slice(5) : model;
-      if (!normalized.startsWith("cli-gemini/") && !normalized.startsWith("cli-claude/")) {
+      if (!normalized.startsWith("cli-gemini/") && !normalized.startsWith("cli-claude/") && !normalized.startsWith("openai-codex/") && !normalized.startsWith("opencode/") && !normalized.startsWith("pi/")) {
         throw new Error(`Unknown CLI bridge model: "${model}"`);
       }
       return `Mock response from ${normalized}`;
@@ -474,4 +518,232 @@ describe("Model capabilities", () => {
       expect(m.capabilities.tools).toBe(true);
     }
   });
+
+  it("openai-codex models have capabilities.tools===false", async () => {
+    const res = await fetch("/v1/models");
+    const body = JSON.parse(res.body);
+    const codexModels = body.data.filter((m: { id: string }) => m.id.startsWith("openai-codex/"));
+    expect(codexModels.length).toBeGreaterThan(0);
+    for (const m of codexModels) {
+      expect(m.capabilities.tools).toBe(false);
+    }
+  });
+
+  it("opencode models have capabilities.tools===false", async () => {
+    const res = await fetch("/v1/models");
+    const body = JSON.parse(res.body);
+    const ocModels = body.data.filter((m: { id: string }) => m.id.startsWith("opencode/"));
+    expect(ocModels.length).toBeGreaterThan(0);
+    for (const m of ocModels) {
+      expect(m.capabilities.tools).toBe(false);
+    }
+  });
+
+  it("pi models have capabilities.tools===false", async () => {
+    const res = await fetch("/v1/models");
+    const body = JSON.parse(res.body);
+    const piModels = body.data.filter((m: { id: string }) => m.id.startsWith("pi/"));
+    expect(piModels.length).toBeGreaterThan(0);
+    for (const m of piModels) {
+      expect(m.capabilities.tools).toBe(false);
+    }
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Chat completions — new model prefixes (codex, opencode, pi)
+// ──────────────────────────────────────────────────────────────────────────────
+
+describe("POST /v1/chat/completions — new model prefixes", () => {
+  it("returns completion for openai-codex model", async () => {
+    const res = await json("/v1/chat/completions", {
+      model: "openai-codex/gpt-5.3-codex",
+      messages: [{ role: "user", content: "hello" }],
+    });
+    expect(res.status).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body.choices[0].message.content).toBe("Mock response from openai-codex/gpt-5.3-codex");
+  });
+
+  it("returns completion for opencode model", async () => {
+    const res = await json("/v1/chat/completions", {
+      model: "opencode/default",
+      messages: [{ role: "user", content: "hello" }],
+    });
+    expect(res.status).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body.choices[0].message.content).toBe("Mock response from opencode/default");
+  });
+
+  it("returns completion for pi model", async () => {
+    const res = await json("/v1/chat/completions", {
+      model: "pi/default",
+      messages: [{ role: "user", content: "hello" }],
+    });
+    expect(res.status).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body.choices[0].message.content).toBe("Mock response from pi/default");
+  });
+
+  it("rejects tools for openai-codex models", async () => {
+    const res = await json("/v1/chat/completions", {
+      model: "openai-codex/gpt-5.3-codex",
+      messages: [{ role: "user", content: "hi" }],
+      tools: [{ type: "function", function: { name: "test", parameters: {} } }],
+    });
+    expect(res.status).toBe(400);
+    expect(JSON.parse(res.body).error.code).toBe("tools_not_supported");
+  });
+
+  it("rejects tools for opencode models", async () => {
+    const res = await json("/v1/chat/completions", {
+      model: "opencode/default",
+      messages: [{ role: "user", content: "hi" }],
+      tools: [{ type: "function", function: { name: "test", parameters: {} } }],
+    });
+    expect(res.status).toBe(400);
+    expect(JSON.parse(res.body).error.code).toBe("tools_not_supported");
+  });
+
+  it("rejects tools for pi models", async () => {
+    const res = await json("/v1/chat/completions", {
+      model: "pi/default",
+      messages: [{ role: "user", content: "hi" }],
+      tools: [{ type: "function", function: { name: "test", parameters: {} } }],
+    });
+    expect(res.status).toBe(400);
+    expect(JSON.parse(res.body).error.code).toBe("tools_not_supported");
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Session Manager endpoints
+// ──────────────────────────────────────────────────────────────────────────────
+
+describe("Session Manager endpoints", () => {
+  beforeEach(() => {
+    mockSessions.clear();
+    nextSessionId = "aabbccdd11223344";
+  });
+
+  it("POST /v1/sessions/spawn returns sessionId", async () => {
+    const res = await json("/v1/sessions/spawn", {
+      model: "cli-gemini/gemini-2.5-pro",
+      messages: [{ role: "user", content: "hello" }],
+    });
+    expect(res.status).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body.sessionId).toBe("aabbccdd11223344");
+  });
+
+  it("POST /v1/sessions/spawn rejects missing model", async () => {
+    const res = await json("/v1/sessions/spawn", {
+      messages: [{ role: "user", content: "hello" }],
+    });
+    expect(res.status).toBe(400);
+    expect(JSON.parse(res.body).error.message).toContain("model and messages are required");
+  });
+
+  it("POST /v1/sessions/spawn rejects missing messages", async () => {
+    const res = await json("/v1/sessions/spawn", {
+      model: "cli-gemini/gemini-2.5-pro",
+      messages: [],
+    });
+    expect(res.status).toBe(400);
+  });
+
+  it("GET /v1/sessions lists sessions", async () => {
+    // Spawn one session first
+    await json("/v1/sessions/spawn", {
+      model: "cli-gemini/gemini-2.5-pro",
+      messages: [{ role: "user", content: "hello" }],
+    });
+
+    const res = await fetch("/v1/sessions");
+    expect(res.status).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body.sessions).toHaveLength(1);
+    expect(body.sessions[0].model).toBe("cli-gemini/gemini-2.5-pro");
+    expect(body.sessions[0].status).toBe("running");
+  });
+
+  it("GET /v1/sessions/:id/poll returns status", async () => {
+    const spawnRes = await json("/v1/sessions/spawn", {
+      model: "cli-gemini/gemini-2.5-pro",
+      messages: [{ role: "user", content: "hello" }],
+    });
+    const { sessionId } = JSON.parse(spawnRes.body);
+
+    const res = await fetch(`/v1/sessions/${sessionId}/poll`);
+    expect(res.status).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body.running).toBe(true);
+    expect(body.status).toBe("running");
+  });
+
+  it("GET /v1/sessions/:id/poll returns 404 for unknown session", async () => {
+    const res = await fetch("/v1/sessions/0000000000000000/poll");
+    expect(res.status).toBe(404);
+  });
+
+  it("GET /v1/sessions/:id/log returns output", async () => {
+    const spawnRes = await json("/v1/sessions/spawn", {
+      model: "cli-gemini/gemini-2.5-pro",
+      messages: [{ role: "user", content: "hello" }],
+    });
+    const { sessionId } = JSON.parse(spawnRes.body);
+
+    const res = await fetch(`/v1/sessions/${sessionId}/log`);
+    expect(res.status).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(typeof body.stdout).toBe("string");
+    expect(typeof body.stderr).toBe("string");
+    expect(typeof body.offset).toBe("number");
+  });
+
+  it("GET /v1/sessions/:id/log returns 404 for unknown session", async () => {
+    const res = await fetch("/v1/sessions/0000000000000000/log");
+    expect(res.status).toBe(404);
+  });
+
+  it("POST /v1/sessions/:id/write sends data", async () => {
+    const spawnRes = await json("/v1/sessions/spawn", {
+      model: "cli-gemini/gemini-2.5-pro",
+      messages: [{ role: "user", content: "hello" }],
+    });
+    const { sessionId } = JSON.parse(spawnRes.body);
+
+    const res = await json(`/v1/sessions/${sessionId}/write`, { data: "input" });
+    expect(res.status).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body.ok).toBe(true);
+  });
+
+  it("POST /v1/sessions/:id/kill terminates session", async () => {
+    const spawnRes = await json("/v1/sessions/spawn", {
+      model: "cli-gemini/gemini-2.5-pro",
+      messages: [{ role: "user", content: "hello" }],
+    });
+    const { sessionId } = JSON.parse(spawnRes.body);
+
+    const res = await json(`/v1/sessions/${sessionId}/kill`, {});
+    expect(res.status).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body.ok).toBe(true);
+  });
+
+  it("POST /v1/sessions/:id/kill returns false for already-killed session", async () => {
+    const spawnRes = await json("/v1/sessions/spawn", {
+      model: "cli-gemini/gemini-2.5-pro",
+      messages: [{ role: "user", content: "hello" }],
+    });
+    const { sessionId } = JSON.parse(spawnRes.body);
+
+    // Kill once
+    await json(`/v1/sessions/${sessionId}/kill`, {});
+    // Kill again
+    const res = await json(`/v1/sessions/${sessionId}/kill`, {});
+    expect(res.status).toBe(404);
+    expect(JSON.parse(res.body).ok).toBe(false);
+  });
 });

package/test/session-manager.test.ts

@@ -0,0 +1,339 @@
+/**
+ * Unit tests for SessionManager.
+ *
+ * Mocks child_process.spawn so no real CLIs are executed.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { EventEmitter } from "node:events";
+import type { ChildProcess } from "node:child_process";
+
+// ── Mock child_process.spawn ────────────────────────────────────────────────
+
+/** Minimal fake ChildProcess for testing. */
+function makeFakeProc(): ChildProcess & {
+  _stdout: EventEmitter;
+  _stderr: EventEmitter;
+  _emit: (event: string, ...args: unknown[]) => void;
+} {
+  const proc = new EventEmitter() as any;
+  proc._stdout = new EventEmitter();
+  proc._stderr = new EventEmitter();
+  proc.stdout = proc._stdout;
+  proc.stderr = proc._stderr;
+  proc.stdin = {
+    write: vi.fn((_data: string, _enc: string, cb?: () => void) => { cb?.(); }),
+    end: vi.fn(),
+  };
+  proc.kill = vi.fn(() => true);
+  proc.pid = 12345;
+  proc._emit = (event: string, ...args: unknown[]) => proc.emit(event, ...args);
+  return proc;
+}
+
+// vi.hoisted variables are available inside vi.mock factories
+const { mockSpawn, mockExecSync, latestProcRef } = vi.hoisted(() => ({
+  mockSpawn: vi.fn(),
+  mockExecSync: vi.fn(),
+  latestProcRef: { current: null as any },
+}));
+
+vi.mock("node:child_process", async (importOriginal) => {
+  const orig = await importOriginal<typeof import("node:child_process")>();
+  return { ...orig, spawn: mockSpawn, execSync: mockExecSync };
+});
+
+// Mock claude-auth to prevent real token operations
+vi.mock("../src/claude-auth.js", () => ({
+  ensureClaudeToken: vi.fn(async () => {}),
+  refreshClaudeToken: vi.fn(async () => {}),
+  scheduleTokenRefresh: vi.fn(async () => {}),
+  stopTokenRefresh: vi.fn(),
+  setAuthLogger: vi.fn(),
+}));
+
+// Now import SessionManager (uses the mocked spawn)
+import { SessionManager } from "../src/session-manager.js";
+
+// ──────────────────────────────────────────────────────────────────────────────
+
+describe("SessionManager", () => {
+  let mgr: SessionManager;
+
+  beforeEach(() => {
+    mgr = new SessionManager();
+    mockSpawn.mockImplementation(() => {
+      const proc = makeFakeProc();
+      latestProcRef.current = proc;
+      return proc;
+    });
+  });
+
+  afterEach(() => {
+    mgr.stop();
+  });
+
+  // ── spawn() ──────────────────────────────────────────────────────────────
+
+  describe("spawn()", () => {
+    it("returns a hex sessionId", () => {
+      const id = mgr.spawn("cli-gemini/gemini-2.5-pro", [{ role: "user", content: "hi" }]);
+      expect(id).toMatch(/^[a-f0-9]{16}$/);
+    });
+
+    it("returns unique sessionIds on repeated calls", () => {
+      const id1 = mgr.spawn("cli-gemini/gemini-2.5-pro", [{ role: "user", content: "a" }]);
+      const id2 = mgr.spawn("cli-gemini/gemini-2.5-pro", [{ role: "user", content: "b" }]);
+      expect(id1).not.toBe(id2);
+    });
+  });
+
+  // ── poll() ─────────────────────────────────────────────────────────────
+
+  describe("poll()", () => {
+    it("returns running status for an active session", () => {
+      const id = mgr.spawn("cli-gemini/gemini-2.5-pro", [{ role: "user", content: "hi" }]);
+      const result = mgr.poll(id);
+      expect(result).not.toBeNull();
+      expect(result!.running).toBe(true);
+      expect(result!.status).toBe("running");
+      expect(result!.exitCode).toBeNull();
+    });
+
+    it("returns exited status after process closes", () => {
+      const id = mgr.spawn("cli-gemini/gemini-2.5-pro", [{ role: "user", content: "hi" }]);
+      // Simulate process exit
+      latestProcRef.current._emit("close", 0);
+      const result = mgr.poll(id);
+      expect(result!.running).toBe(false);
+      expect(result!.status).toBe("exited");
+      expect(result!.exitCode).toBe(0);
+    });
+
+    it("returns null for unknown sessionId", () => {
+      expect(mgr.poll("0000000000000000")).toBeNull();
+    });
+  });
+
+  // ── log() ──────────────────────────────────────────────────────────────
+
+  describe("log()", () => {
+    it("returns buffered stdout output", () => {
+      const id = mgr.spawn("cli-gemini/gemini-2.5-pro", [{ role: "user", content: "hi" }]);
+      latestProcRef.current._stdout.emit("data", Buffer.from("Hello "));
+      latestProcRef.current._stdout.emit("data", Buffer.from("World"));
+      const result = mgr.log(id);
+      expect(result).not.toBeNull();
+      expect(result!.stdout).toBe("Hello World");
+      expect(result!.offset).toBe(11);
+    });
+
+    it("returns buffered stderr output", () => {
+      const id = mgr.spawn("cli-gemini/gemini-2.5-pro", [{ role: "user", content: "hi" }]);
+      latestProcRef.current._stderr.emit("data", Buffer.from("warning"));
+      const result = mgr.log(id);
+      expect(result!.stderr).toBe("warning");
+    });
+
+    it("supports offset to get incremental output", () => {
+      const id = mgr.spawn("cli-gemini/gemini-2.5-pro", [{ role: "user", content: "hi" }]);
+      latestProcRef.current._stdout.emit("data", Buffer.from("ABCDE"));
+      const result = mgr.log(id, 3);
+      expect(result!.stdout).toBe("DE");
+      expect(result!.offset).toBe(5);
+    });
+
+    it("returns null for unknown sessionId", () => {
+      expect(mgr.log("0000000000000000")).toBeNull();
+    });
+  });
+
+  // ── write() ────────────────────────────────────────────────────────────
+
+  describe("write()", () => {
+    it("writes data to stdin of a running session", () => {
+      const id = mgr.spawn("cli-gemini/gemini-2.5-pro", [{ role: "user", content: "hi" }]);
+      const proc = latestProcRef.current;
+      const ok = mgr.write(id, "input data");
+      expect(ok).toBe(true);
+      expect(proc.stdin.write).toHaveBeenCalledWith("input data", "utf8");
+    });
+
+    it("returns false for unknown sessionId", () => {
+      expect(mgr.write("0000000000000000", "data")).toBe(false);
+    });
+
+    it("returns false for an exited session", () => {
+      const id = mgr.spawn("cli-gemini/gemini-2.5-pro", [{ role: "user", content: "hi" }]);
+      latestProcRef.current._emit("close", 0);
+      expect(mgr.write(id, "data")).toBe(false);
+    });
+  });
+
+  // ── kill() ─────────────────────────────────────────────────────────────
+
+  describe("kill()", () => {
+    it("sends SIGTERM to a running session", () => {
+      const id = mgr.spawn("cli-gemini/gemini-2.5-pro", [{ role: "user", content: "hi" }]);
+      const proc = latestProcRef.current;
+      const ok = mgr.kill(id);
+      expect(ok).toBe(true);
+      expect(proc.kill).toHaveBeenCalledWith("SIGTERM");
+      // Status should be "killed"
+      const poll = mgr.poll(id);
+      expect(poll!.status).toBe("killed");
+    });
+
+    it("returns false for unknown sessionId", () => {
+      expect(mgr.kill("0000000000000000")).toBe(false);
+    });
+
+    it("returns false for an already-exited session", () => {
+      const id = mgr.spawn("cli-gemini/gemini-2.5-pro", [{ role: "user", content: "hi" }]);
+      latestProcRef.current._emit("close", 0);
+      expect(mgr.kill(id)).toBe(false);
+    });
+  });
+
+  // ── list() ─────────────────────────────────────────────────────────────
+
+  describe("list()", () => {
+    it("returns all sessions", () => {
+      mgr.spawn("cli-gemini/gemini-2.5-pro", [{ role: "user", content: "a" }]);
+      mgr.spawn("cli-claude/claude-sonnet-4-6", [{ role: "user", content: "b" }]);
+      const list = mgr.list();
+      expect(list).toHaveLength(2);
+      expect(list[0].sessionId).toMatch(/^[a-f0-9]{16}$/);
+      expect(list[0].model).toBe("cli-gemini/gemini-2.5-pro");
+      expect(list[0].status).toBe("running");
+      expect(list[1].model).toBe("cli-claude/claude-sonnet-4-6");
+    });
+
+    it("returns empty array when no sessions exist", () => {
+      expect(mgr.list()).toHaveLength(0);
+    });
+  });
+
+  // ── cleanup() ──────────────────────────────────────────────────────────
+
+  describe("cleanup()", () => {
+    it("removes sessions older than TTL", () => {
+      const id = mgr.spawn("cli-gemini/gemini-2.5-pro", [{ role: "user", content: "hi" }]);
+
+      // Manually set startTime to far in the past
+      const sessions = (mgr as any).sessions as Map<string, any>;
+      const entry = sessions.get(id)!;
+      entry.startTime = Date.now() - 31 * 60 * 1000; // 31 minutes ago
+
+      mgr.cleanup();
+
+      expect(mgr.poll(id)).toBeNull();
+      expect(mgr.list()).toHaveLength(0);
+    });
+
+    it("kills running sessions before removing them", () => {
+      const id = mgr.spawn("cli-gemini/gemini-2.5-pro", [{ role: "user", content: "hi" }]);
+      const proc = latestProcRef.current;
+
+      const sessions = (mgr as any).sessions as Map<string, any>;
+      sessions.get(id)!.startTime = Date.now() - 31 * 60 * 1000;
+
+      mgr.cleanup();
+
+      expect(proc.kill).toHaveBeenCalledWith("SIGTERM");
+    });
+
+    it("does not remove recent sessions", () => {
+      mgr.spawn("cli-gemini/gemini-2.5-pro", [{ role: "user", content: "hi" }]);
+      mgr.cleanup();
+      expect(mgr.list()).toHaveLength(1);
+    });
+  });
+
+  // ── resolveCliCommand (via spawn behavior) ─────────────────────────────
+
+  describe("resolveCliCommand routing", () => {
+    it("routes cli-gemini/ to 'gemini' command", () => {
+      mgr.spawn("cli-gemini/gemini-2.5-pro", [{ role: "user", content: "test" }]);
+      expect(mockSpawn).toHaveBeenCalledWith(
+        "gemini",
+        expect.arrayContaining(["-m", "gemini-2.5-pro"]),
+        expect.any(Object)
+      );
+    });
+
+    it("routes cli-claude/ to 'claude' command", () => {
+      mgr.spawn("cli-claude/claude-sonnet-4-6", [{ role: "user", content: "test" }]);
+      expect(mockSpawn).toHaveBeenCalledWith(
+        "claude",
+        expect.arrayContaining(["--model", "claude-sonnet-4-6"]),
+        expect.any(Object)
+      );
+    });
+
+    it("routes openai-codex/ to 'codex' command", () => {
+      mgr.spawn("openai-codex/gpt-5.3-codex", [{ role: "user", content: "test" }]);
+      expect(mockSpawn).toHaveBeenCalledWith(
+        "codex",
+        expect.arrayContaining(["--model", "gpt-5.3-codex"]),
+        expect.any(Object)
+      );
+    });
+
+    it("routes opencode/ to 'opencode' command", () => {
+      mgr.spawn("opencode/default", [{ role: "user", content: "test" }]);
+      expect(mockSpawn).toHaveBeenCalledWith(
+        "opencode",
+        expect.arrayContaining(["run"]),
+        expect.any(Object)
+      );
+    });
+
+    it("routes pi/ to 'pi' command", () => {
+      mgr.spawn("pi/default", [{ role: "user", content: "test" }]);
+      expect(mockSpawn).toHaveBeenCalledWith(
+        "pi",
+        expect.arrayContaining(["-p"]),
+        expect.any(Object)
+      );
+    });
+
+    it("passes workdir option as cwd", () => {
+      mgr.spawn("cli-gemini/gemini-2.5-pro", [{ role: "user", content: "test" }], { workdir: "/tmp/test" });
+      expect(mockSpawn).toHaveBeenCalledWith(
+        "gemini",
+        expect.any(Array),
+        expect.objectContaining({ cwd: "/tmp/test" })
+      );
+    });
+  });
+
+  // ── process error handling ─────────────────────────────────────────────
+
+  describe("process error handling", () => {
+    it("marks session as exited on process error", () => {
+      const id = mgr.spawn("cli-gemini/gemini-2.5-pro", [{ role: "user", content: "hi" }]);
+      latestProcRef.current._emit("error", new Error("spawn ENOENT"));
+      const result = mgr.poll(id);
+      expect(result!.running).toBe(false);
+      expect(result!.status).toBe("exited");
+      expect(result!.exitCode).toBe(1);
+    });
+  });
+
+  // ── stop() ─────────────────────────────────────────────────────────────
+
+  describe("stop()", () => {
+    it("kills all running sessions", () => {
+      mgr.spawn("cli-gemini/gemini-2.5-pro", [{ role: "user", content: "a" }]);
+      const proc1 = latestProcRef.current;
+      mgr.spawn("cli-claude/claude-sonnet-4-6", [{ role: "user", content: "b" }]);
+      const proc2 = latestProcRef.current;
+
+      mgr.stop();
+
+      expect(proc1.kill).toHaveBeenCalledWith("SIGTERM");
+      expect(proc2.kill).toHaveBeenCalledWith("SIGTERM");
+    });
+  });
+});