chatccc 0.2.196 → 0.2.198

package/src/__tests__/chrome-devtools-guard.test.ts

@@ -1,165 +1,165 @@
-import { describe, expect, it, vi } from "vitest";
-import { spawn } from "node:child_process";
-
-import {
-  ensureChromeCdpRunning,
-  ensureChatcccPageOpen,
-  isChromeCdpHealthy,
-  probeChromeCdp,
-  resolveChromeExecutable,
-  resolveChromeUserDataDir,
-} from "../chrome-devtools-guard.ts";
-
-describe("Chrome CDP guard", () => {
-  it("treats /json/version with Browser as healthy", async () => {
-    const fetchImpl = vi.fn(async () =>
-      new Response(JSON.stringify({ Browser: "Chrome/144.0.0.0" }), { status: 200 }),
-    ) as unknown as typeof fetch;
-
-    await expect(isChromeCdpHealthy(15166, { fetchImpl })).resolves.toBe(true);
-  });
-
-  it("does not spawn Chrome when the CDP endpoint is already healthy", async () => {
-    const fetchImpl = vi.fn(async () =>
-      new Response(JSON.stringify({ webSocketDebuggerUrl: "ws://127.0.0.1:15166/devtools/browser/1" }), { status: 200 }),
-    ) as unknown as typeof fetch;
-    const spawnImpl = vi.fn() as unknown as typeof spawn;
-
-    await expect(
-      ensureChromeCdpRunning(
-        { enabled: true, port: 15166, chromePath: "C:/Chrome/chrome.exe" },
-        { fetchImpl, spawnImpl },
-      ),
-    ).resolves.toEqual({ ok: true, started: false, port: 15166 });
-    expect(spawnImpl).not.toHaveBeenCalled();
-  });
-
-  it("spawns Chrome with a dedicated profile when the endpoint is unhealthy", async () => {
-    const fetchImpl = vi.fn()
-      .mockRejectedValueOnce(new Error("ECONNREFUSED"))
-      .mockResolvedValue(new Response(JSON.stringify({ Browser: "Chrome/144.0.0.0" }), { status: 200 })) as unknown as typeof fetch;
-    const unref = vi.fn();
-    const spawnImpl = vi.fn(() => ({ unref })) as unknown as typeof spawn;
-    const mkdirSyncImpl = vi.fn();
-
-    await expect(
-      ensureChromeCdpRunning(
-        { enabled: true, port: 15166, chromePath: "C:/Chrome/chrome.exe" },
-        {
-          fetchImpl,
-          spawnImpl,
-          mkdirSyncImpl: mkdirSyncImpl as never,
-          existsSyncImpl: vi.fn(() => true),
-          env: { LOCALAPPDATA: "C:/Users/me/AppData/Local" },
-        },
-      ),
-    ).resolves.toEqual({ ok: true, started: true, port: 15166 });
-
-    expect(mkdirSyncImpl).toHaveBeenCalledWith("C:\\Users\\me\\AppData\\Local\\chatccc\\chrome-cdp-15166", { recursive: true });
-    expect(spawnImpl).toHaveBeenCalledWith(
-      "C:/Chrome/chrome.exe",
-      expect.arrayContaining([
-        "--remote-debugging-address=127.0.0.1",
-        "--remote-debugging-port=15166",
-        "--user-data-dir=C:\\Users\\me\\AppData\\Local\\chatccc\\chrome-cdp-15166",
-        "--new-window",
-        "about:blank",
-      ]),
-      expect.objectContaining({ detached: true, stdio: "ignore", windowsHide: true }),
-    );
-    expect(unref).toHaveBeenCalled();
-  });
-
-  it("does not spawn Chrome when the port is occupied by a non-CDP service", async () => {
-    const fetchImpl = vi.fn(async () => new Response("not found", { status: 404 })) as unknown as typeof fetch;
-    const spawnImpl = vi.fn() as unknown as typeof spawn;
-
-    await expect(probeChromeCdp(15166, { fetchImpl })).resolves.toBe("occupied");
-    await expect(
-      ensureChromeCdpRunning(
-        { enabled: true, port: 15166, chromePath: "C:/Chrome/chrome.exe" },
-        { fetchImpl, spawnImpl },
-      ),
-    ).resolves.toMatchObject({
-      ok: false,
-      started: false,
-      port: 15166,
-      error: expect.stringContaining("not a healthy Chrome CDP endpoint"),
-    });
-    expect(spawnImpl).not.toHaveBeenCalled();
-  });
-
-  it("reports a clear error when Chrome cannot be found", async () => {
-    const fetchImpl = vi.fn(async () => { throw new Error("ECONNREFUSED"); }) as unknown as typeof fetch;
-
-    await expect(
-      ensureChromeCdpRunning(
-        { enabled: true, port: 15166, chromePath: "" },
-        {
-          fetchImpl,
-          existsSyncImpl: vi.fn(() => false),
-          platform: "win32",
-          env: {},
-        },
-      ),
-    ).resolves.toMatchObject({
-      ok: false,
-      started: false,
-      port: 15166,
-      error: expect.stringContaining("Cannot find chrome executable"),
-    });
-  });
-
-  it("resolves explicit and default Chrome paths", () => {
-    expect(resolveChromeExecutable("C:/Chrome/chrome.exe", { existsSyncImpl: vi.fn(() => true) })).toBe("C:/Chrome/chrome.exe");
-    expect(resolveChromeExecutable("", {
-      existsSyncImpl: vi.fn((p: unknown) => String(p).endsWith("Google\\Chrome\\Application\\chrome.exe")),
-      platform: "win32",
-      env: { ProgramFiles: "C:/Program Files" },
-    })).toBe("C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe");
-  });
-
-  it("uses LocalAppData for the Chrome CDP user data directory", () => {
-    expect(resolveChromeUserDataDir(15166, { LOCALAPPDATA: "C:/Users/me/AppData/Local" }))
-      .toBe("C:\\Users\\me\\AppData\\Local\\chatccc\\chrome-cdp-15166");
-  });
-
-  it("opens the configured ChatCCC page when no localhost or loopback page is present", async () => {
-    const fetchImpl = vi.fn(async (input: string | URL | Request, init?: RequestInit) => {
-      const url = String(input);
-      if (url === "http://127.0.0.1:15166/json/list") {
-        return new Response(JSON.stringify([
-          { id: "chatgpt", type: "page", url: "https://chatgpt.com/", webSocketDebuggerUrl: "ws://page" },
-        ]), { status: 200 });
-      }
-      if (url === "http://127.0.0.1:15166/json/new?http%3A%2F%2Flocalhost%3A18081%2F") {
-        expect(init?.method).toBe("PUT");
-        return new Response(JSON.stringify({ id: "chatccc" }), { status: 200 });
-      }
-      throw new Error(`unexpected fetch ${url}`);
-    }) as unknown as typeof fetch;
-
-    await expect(ensureChatcccPageOpen(15166, 18081, { fetchImpl })).resolves.toEqual({
-      ok: true,
-      opened: true,
-    });
-  });
-
-  it("does not open another ChatCCC page when localhost or 127.0.0.1 is already present", async () => {
-    const fetchImpl = vi.fn(async (input: string | URL | Request) => {
-      const url = String(input);
-      if (url === "http://127.0.0.1:15166/json/list") {
-        return new Response(JSON.stringify([
-          { id: "chatccc", type: "page", url: "http://127.0.0.1:18080/", webSocketDebuggerUrl: "ws://page" },
-        ]), { status: 200 });
-      }
-      throw new Error(`unexpected fetch ${url}`);
-    }) as unknown as typeof fetch;
-
-    await expect(ensureChatcccPageOpen(15166, 18080, { fetchImpl })).resolves.toEqual({
-      ok: true,
-      opened: false,
-    });
-    expect(fetchImpl).toHaveBeenCalledTimes(1);
-  });
-});
+import { describe, expect, it, vi } from "vitest";
+import { spawn } from "node:child_process";
+
+import {
+  ensureChromeCdpRunning,
+  ensureChatcccPageOpen,
+  isChromeCdpHealthy,
+  probeChromeCdp,
+  resolveChromeExecutable,
+  resolveChromeUserDataDir,
+} from "../chrome-devtools-guard.ts";
+
+describe("Chrome CDP guard", () => {
+  it("treats /json/version with Browser as healthy", async () => {
+    const fetchImpl = vi.fn(async () =>
+      new Response(JSON.stringify({ Browser: "Chrome/144.0.0.0" }), { status: 200 }),
+    ) as unknown as typeof fetch;
+
+    await expect(isChromeCdpHealthy(15166, { fetchImpl })).resolves.toBe(true);
+  });
+
+  it("does not spawn Chrome when the CDP endpoint is already healthy", async () => {
+    const fetchImpl = vi.fn(async () =>
+      new Response(JSON.stringify({ webSocketDebuggerUrl: "ws://127.0.0.1:15166/devtools/browser/1" }), { status: 200 }),
+    ) as unknown as typeof fetch;
+    const spawnImpl = vi.fn() as unknown as typeof spawn;
+
+    await expect(
+      ensureChromeCdpRunning(
+        { enabled: true, port: 15166, chromePath: "C:/Chrome/chrome.exe" },
+        { fetchImpl, spawnImpl },
+      ),
+    ).resolves.toEqual({ ok: true, started: false, port: 15166 });
+    expect(spawnImpl).not.toHaveBeenCalled();
+  });
+
+  it("spawns Chrome with a dedicated profile when the endpoint is unhealthy", async () => {
+    const fetchImpl = vi.fn()
+      .mockRejectedValueOnce(new Error("ECONNREFUSED"))
+      .mockResolvedValue(new Response(JSON.stringify({ Browser: "Chrome/144.0.0.0" }), { status: 200 })) as unknown as typeof fetch;
+    const unref = vi.fn();
+    const spawnImpl = vi.fn(() => ({ unref })) as unknown as typeof spawn;
+    const mkdirSyncImpl = vi.fn();
+
+    await expect(
+      ensureChromeCdpRunning(
+        { enabled: true, port: 15166, chromePath: "C:/Chrome/chrome.exe" },
+        {
+          fetchImpl,
+          spawnImpl,
+          mkdirSyncImpl: mkdirSyncImpl as never,
+          existsSyncImpl: vi.fn(() => true),
+          env: { LOCALAPPDATA: "C:/Users/me/AppData/Local" },
+        },
+      ),
+    ).resolves.toEqual({ ok: true, started: true, port: 15166 });
+
+    expect(mkdirSyncImpl).toHaveBeenCalledWith("C:\\Users\\me\\AppData\\Local\\chatccc\\chrome-cdp-15166", { recursive: true });
+    expect(spawnImpl).toHaveBeenCalledWith(
+      "C:/Chrome/chrome.exe",
+      expect.arrayContaining([
+        "--remote-debugging-address=127.0.0.1",
+        "--remote-debugging-port=15166",
+        "--user-data-dir=C:\\Users\\me\\AppData\\Local\\chatccc\\chrome-cdp-15166",
+        "--new-window",
+        "about:blank",
+      ]),
+      expect.objectContaining({ detached: true, stdio: "ignore", windowsHide: true }),
+    );
+    expect(unref).toHaveBeenCalled();
+  });
+
+  it("does not spawn Chrome when the port is occupied by a non-CDP service", async () => {
+    const fetchImpl = vi.fn(async () => new Response("not found", { status: 404 })) as unknown as typeof fetch;
+    const spawnImpl = vi.fn() as unknown as typeof spawn;
+
+    await expect(probeChromeCdp(15166, { fetchImpl })).resolves.toBe("occupied");
+    await expect(
+      ensureChromeCdpRunning(
+        { enabled: true, port: 15166, chromePath: "C:/Chrome/chrome.exe" },
+        { fetchImpl, spawnImpl },
+      ),
+    ).resolves.toMatchObject({
+      ok: false,
+      started: false,
+      port: 15166,
+      error: expect.stringContaining("not a healthy Chrome CDP endpoint"),
+    });
+    expect(spawnImpl).not.toHaveBeenCalled();
+  });
+
+  it("reports a clear error when Chrome cannot be found", async () => {
+    const fetchImpl = vi.fn(async () => { throw new Error("ECONNREFUSED"); }) as unknown as typeof fetch;
+
+    await expect(
+      ensureChromeCdpRunning(
+        { enabled: true, port: 15166, chromePath: "" },
+        {
+          fetchImpl,
+          existsSyncImpl: vi.fn(() => false),
+          platform: "win32",
+          env: {},
+        },
+      ),
+    ).resolves.toMatchObject({
+      ok: false,
+      started: false,
+      port: 15166,
+      error: expect.stringContaining("Cannot find chrome executable"),
+    });
+  });
+
+  it("resolves explicit and default Chrome paths", () => {
+    expect(resolveChromeExecutable("C:/Chrome/chrome.exe", { existsSyncImpl: vi.fn(() => true) })).toBe("C:/Chrome/chrome.exe");
+    expect(resolveChromeExecutable("", {
+      existsSyncImpl: vi.fn((p: unknown) => String(p).endsWith("Google\\Chrome\\Application\\chrome.exe")),
+      platform: "win32",
+      env: { ProgramFiles: "C:/Program Files" },
+    })).toBe("C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe");
+  });
+
+  it("uses LocalAppData for the Chrome CDP user data directory", () => {
+    expect(resolveChromeUserDataDir(15166, { LOCALAPPDATA: "C:/Users/me/AppData/Local" }))
+      .toBe("C:\\Users\\me\\AppData\\Local\\chatccc\\chrome-cdp-15166");
+  });
+
+  it("opens the configured ChatCCC page when no localhost or loopback page is present", async () => {
+    const fetchImpl = vi.fn(async (input: string | URL | Request, init?: RequestInit) => {
+      const url = String(input);
+      if (url === "http://127.0.0.1:15166/json/list") {
+        return new Response(JSON.stringify([
+          { id: "chatgpt", type: "page", url: "https://chatgpt.com/", webSocketDebuggerUrl: "ws://page" },
+        ]), { status: 200 });
+      }
+      if (url === "http://127.0.0.1:15166/json/new?http%3A%2F%2Flocalhost%3A18081%2F") {
+        expect(init?.method).toBe("PUT");
+        return new Response(JSON.stringify({ id: "chatccc" }), { status: 200 });
+      }
+      throw new Error(`unexpected fetch ${url}`);
+    }) as unknown as typeof fetch;
+
+    await expect(ensureChatcccPageOpen(15166, 18081, { fetchImpl })).resolves.toEqual({
+      ok: true,
+      opened: true,
+    });
+  });
+
+  it("does not open another ChatCCC page when localhost or 127.0.0.1 is already present", async () => {
+    const fetchImpl = vi.fn(async (input: string | URL | Request) => {
+      const url = String(input);
+      if (url === "http://127.0.0.1:15166/json/list") {
+        return new Response(JSON.stringify([
+          { id: "chatccc", type: "page", url: "http://127.0.0.1:18080/", webSocketDebuggerUrl: "ws://page" },
+        ]), { status: 200 });
+      }
+      throw new Error(`unexpected fetch ${url}`);
+    }) as unknown as typeof fetch;
+
+    await expect(ensureChatcccPageOpen(15166, 18080, { fetchImpl })).resolves.toEqual({
+      ok: true,
+      opened: false,
+    });
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+  });
+});

package/src/__tests__/claude-raw-stream-log.test.ts

@@ -0,0 +1,87 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const resumeSessionMock = vi.hoisted(() => vi.fn());
+const createRawStreamLogMock = vi.hoisted(() => vi.fn());
+const rawLogWriteLineMock = vi.hoisted(() => vi.fn());
+const rawLogCloseMock = vi.hoisted(() => vi.fn());
+
+vi.mock("@anthropic-ai/claude-agent-sdk", () => ({
+  getSessionInfo: vi.fn(),
+  unstable_v2_createSession: vi.fn(),
+  unstable_v2_resumeSession: resumeSessionMock,
+}));
+
+vi.mock("../adapters/raw-stream-log.ts", () => ({
+  createRawStreamLog: createRawStreamLogMock,
+}));
+
+import { config } from "../config.ts";
+import { createClaudeAdapter } from "../adapters/claude-adapter.ts";
+
+const originalRawStreamLogs = structuredClone(config.rawStreamLogs);
+
+async function collect(iterable: AsyncIterable<unknown>): Promise<unknown[]> {
+  const events: unknown[] = [];
+  for await (const event of iterable) events.push(event);
+  return events;
+}
+
+afterEach(() => {
+  resumeSessionMock.mockReset();
+  createRawStreamLogMock.mockReset();
+  rawLogWriteLineMock.mockReset();
+  rawLogCloseMock.mockReset();
+  config.rawStreamLogs = structuredClone(originalRawStreamLogs);
+});
+
+describe("Claude raw stream logs", () => {
+  it("writes raw Claude SDK stream messages when enabled", async () => {
+    const rawMessages = [
+      { type: "system", subtype: "init", session_id: "sid-raw", cwd: "F:/project", model: "claude-test" },
+      { type: "assistant", message: { content: [{ type: "text", text: "hello" }] } },
+    ];
+    const session = {
+      send: vi.fn(async () => {}),
+      stream: async function* () {
+        for (const msg of rawMessages) yield msg;
+      },
+      close: vi.fn(),
+    };
+    resumeSessionMock.mockReturnValueOnce(session);
+    createRawStreamLogMock.mockResolvedValueOnce({
+      filePath: "claude.jsonl.gz",
+      writeLine: rawLogWriteLineMock,
+      close: rawLogCloseMock,
+    });
+    config.rawStreamLogs.claude = {
+      enabled: true,
+      maxBytesPerTurn: 4096,
+      retentionDays: 5,
+      keepCompleted: false,
+    };
+
+    const adapter = createClaudeAdapter({
+      model: "claude-test",
+      effort: "high",
+      isEmpty: (value) => value.trim() === "",
+    });
+    const events = await collect(adapter.prompt("sid-raw", "hi", "F:/project"));
+
+    expect(createRawStreamLogMock).toHaveBeenCalledWith(expect.objectContaining({
+      enabled: true,
+      tool: "claude",
+      sessionId: "sid-raw",
+      label: "prompt",
+      maxBytesPerTurn: 4096,
+      retentionDays: 5,
+    }));
+    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(1, JSON.stringify(rawMessages[0]));
+    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(2, JSON.stringify(rawMessages[1]));
+    expect(rawLogCloseMock).toHaveBeenCalledWith({ keep: false });
+    expect(session.close).toHaveBeenCalledOnce();
+    expect(events).toContainEqual({
+      type: "assistant",
+      blocks: [{ type: "text", text: "hello" }],
+    });
+  });
+});

package/src/__tests__/codex-raw-stream-log.test.ts

@@ -0,0 +1,163 @@
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const spawnMock = vi.hoisted(() => vi.fn());
+const createRawStreamLogMock = vi.hoisted(() => vi.fn());
+const rawLogWriteLineMock = vi.hoisted(() => vi.fn());
+const rawLogCloseMock = vi.hoisted(() => vi.fn());
+const killProcessTreeMock = vi.hoisted(() => vi.fn(async () => {}));
+
+vi.mock("node:child_process", () => ({
+  spawn: spawnMock,
+}));
+
+vi.mock("../adapters/raw-stream-log.ts", () => ({
+  createRawStreamLog: createRawStreamLogMock,
+}));
+
+vi.mock("../adapters/proc-tree-kill.ts", () => ({
+  killProcessTree: killProcessTreeMock,
+}));
+
+import { config } from "../config.ts";
+import { createCodexAdapter } from "../adapters/codex-adapter.ts";
+import { BadJsonIdleTimeoutError } from "../adapters/jsonl-stream.ts";
+import type { CodexSessionMetaStore } from "../adapters/codex-session-meta-store.ts";
+
+const originalRawStreamLogs = structuredClone(config.rawStreamLogs);
+
+function createProc(lines: string[]): EventEmitter & {
+  stdout: PassThrough;
+  stderr: PassThrough;
+  stdin: PassThrough;
+  pid: number;
+} {
+  const proc = new EventEmitter() as EventEmitter & {
+    stdout: PassThrough;
+    stderr: PassThrough;
+    stdin: PassThrough;
+    pid: number;
+  };
+  proc.stdout = new PassThrough();
+  proc.stderr = new PassThrough();
+  proc.stdin = new PassThrough();
+  proc.pid = 4242;
+  queueMicrotask(() => {
+    for (const line of lines) proc.stdout.write(`${line}\n`);
+    proc.stdout.end();
+    proc.stderr.end();
+    proc.emit("close", 0);
+  });
+  return proc;
+}
+
+function createHangingProc(lines: string[]): EventEmitter & {
+  stdout: PassThrough;
+  stderr: PassThrough;
+  stdin: PassThrough;
+  pid: number;
+} {
+  const proc = new EventEmitter() as EventEmitter & {
+    stdout: PassThrough;
+    stderr: PassThrough;
+    stdin: PassThrough;
+    pid: number;
+  };
+  proc.stdout = new PassThrough();
+  proc.stderr = new PassThrough();
+  proc.stdin = new PassThrough();
+  proc.pid = 4242;
+  queueMicrotask(() => {
+    for (const line of lines) proc.stdout.write(`${line}\n`);
+  });
+  return proc;
+}
+
+async function collect(iterable: AsyncIterable<unknown>): Promise<unknown[]> {
+  const events: unknown[] = [];
+  for await (const event of iterable) events.push(event);
+  return events;
+}
+
+function metaStore(): CodexSessionMetaStore {
+  return {
+    async get(sessionId) {
+      return sessionId === "sid-raw" ? { cwd: "F:/project" } : undefined;
+    },
+    async set() {},
+    async setThreadId() {},
+  };
+}
+
+afterEach(() => {
+  vi.useRealTimers();
+  spawnMock.mockReset();
+  createRawStreamLogMock.mockReset();
+  rawLogWriteLineMock.mockReset();
+  rawLogCloseMock.mockReset();
+  killProcessTreeMock.mockClear();
+  config.rawStreamLogs = structuredClone(originalRawStreamLogs);
+});
+
+describe("Codex raw stream logs", () => {
+  it("writes raw Codex JSONL stdout lines when enabled", async () => {
+    const lines = [
+      JSON.stringify({ type: "thread.started", thread_id: "thread-1" }),
+      JSON.stringify({ type: "item.completed", item: { id: "item-1", type: "agent_message", text: "hello" } }),
+      JSON.stringify({ type: "turn.completed" }),
+    ];
+    spawnMock.mockReturnValueOnce(createProc(lines));
+    createRawStreamLogMock.mockResolvedValueOnce({
+      filePath: "codex.jsonl.gz",
+      writeLine: rawLogWriteLineMock,
+      close: rawLogCloseMock,
+    });
+    config.rawStreamLogs.codex = {
+      enabled: true,
+      maxBytesPerTurn: 2048,
+      retentionDays: 2,
+      keepCompleted: false,
+    };
+
+    const adapter = createCodexAdapter({ metaStore: metaStore() });
+    const events = await collect(adapter.prompt("sid-raw", "hi", "F:/project"));
+
+    expect(createRawStreamLogMock).toHaveBeenCalledWith(expect.objectContaining({
+      enabled: true,
+      tool: "codex",
+      sessionId: "sid-raw",
+      label: "prompt",
+      maxBytesPerTurn: 2048,
+      retentionDays: 2,
+    }));
+    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(1, lines[0]);
+    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(2, lines[1]);
+    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(3, lines[2]);
+    expect(rawLogCloseMock).toHaveBeenCalledWith({ keep: false });
+    expect(events).toContainEqual({
+      type: "assistant",
+      blocks: [{ type: "text", text: "hello" }],
+    });
+  });
+
+  it("fails the turn and kills the process tree when bad JSON is followed by idle stdout", async () => {
+    vi.useFakeTimers();
+    spawnMock.mockReturnValueOnce(createHangingProc([
+      "{\"type\":\"item.started\",\"item\":{\"type\":\"command_execution\"",
+    ]));
+    createRawStreamLogMock.mockResolvedValueOnce(null);
+
+    const adapter = createCodexAdapter({ metaStore: metaStore() });
+    const pending = collect(adapter.prompt("sid-raw", "hi", "F:/project"))
+      .catch((error: unknown) => error);
+
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(120_000);
+
+    const error = await pending;
+    expect(error).toBeInstanceOf(BadJsonIdleTimeoutError);
+    expect(killProcessTreeMock).toHaveBeenCalledWith(4242);
+  });
+});

package/src/__tests__/config-reload.test.ts

@@ -45,12 +45,12 @@ const baseAppConfig: AppConfig = {
   port: 18080,
   gitTimeoutSeconds: 180,
   allowInterrupt: false,
-  rawStreamLogs: {
-    claude: { enabled: false, maxBytesPerTurn: 52_428_800, retentionDays: 7, keepCompleted: false },
-    cursor: { enabled: false, maxBytesPerTurn: 52_428_800, retentionDays: 7, keepCompleted: false },
-    codex: { enabled: false, maxBytesPerTurn: 52_428_800, retentionDays: 7, keepCompleted: false },
-    ccc: { enabled: false, maxBytesPerTurn: 52_428_800, retentionDays: 7, keepCompleted: false },
-  },
+  rawStreamLogs: {
+    claude: { enabled: false, maxBytesPerTurn: 52_428_800, retentionDays: 7, keepCompleted: false },
+    cursor: { enabled: false, maxBytesPerTurn: 52_428_800, retentionDays: 7, keepCompleted: false },
+    codex: { enabled: false, maxBytesPerTurn: 52_428_800, retentionDays: 7, keepCompleted: false },
+    ccc: { enabled: false, maxBytesPerTurn: 52_428_800, retentionDays: 7, keepCompleted: false },
+  },
   claude: {
     enabled: true,
     defaultAgent: true,
@@ -69,10 +69,10 @@ const baseAppConfig: AppConfig = {
     alternativeModel: "initial-cursor-alt-model",
     avatarBatteryMode: "apiPercent",
     onDemandMonthlyBudget: 1000,
-  },
-  codex: { enabled: true, defaultAgent: false, path: "/initial/codex", model: "initial-codex-model", alternativeModel: "initial-codex-alt-model", effort: "initial-codex-effort" },
-  ccc: { DEEPSEEK_API_KEY: "initial-ccc-key", DEEPSEEK_BASE_URL: "https://initial.deepseek.test/v1", model: "initial-ccc-model" },
-};
+  },
+  codex: { enabled: true, defaultAgent: false, path: "/initial/codex", model: "initial-codex-model", alternativeModel: "initial-codex-alt-model", effort: "initial-codex-effort" },
+  ccc: { DEEPSEEK_API_KEY: "initial-ccc-key", DEEPSEEK_BASE_URL: "https://initial.deepseek.test/v1", model: "initial-ccc-model" },
+};
 
 // 把 module 状态抢救快照：每个 it 跑前重置回这个状态，避免污染相邻测试。
 // 不直接用启动时的 config 引用做 snapshot——它可能已经被前一个 it 改写。

package/src/__tests__/config-sample.test.ts

@@ -28,29 +28,29 @@ describe("config.sample.json", () => {
     expect(sample.claude?.subagentModel).toBe("");
   });
 
-  it("leaves Cursor and Codex alternative models empty by default", () => {
+  it("leaves Cursor and Codex alternative models empty by default", () => {
     const configSamplePath = join(process.cwd(), "config.sample.json");
     const sample = JSON.parse(readFileSync(configSamplePath, "utf8")) as {
       cursor?: { alternativeModel?: unknown };
       codex?: { alternativeModel?: unknown };
     };
 
-    expect(sample.cursor?.alternativeModel).toBe("");
-    expect(sample.codex?.alternativeModel).toBe("");
-  });
-
-  it("sets ccc agent DeepSeek defaults in the sample config", () => {
-    const configSamplePath = join(process.cwd(), "config.sample.json");
-    const sample = JSON.parse(readFileSync(configSamplePath, "utf8")) as {
-      ccc?: { DEEPSEEK_API_KEY?: unknown; DEEPSEEK_BASE_URL?: unknown; model?: unknown };
-    };
-
-    expect(sample.ccc?.DEEPSEEK_API_KEY).toBe("");
-    expect(sample.ccc?.DEEPSEEK_BASE_URL).toBe("https://api.deepseek.com/v1");
-    expect(sample.ccc?.model).toBe("deepseek-v4-pro");
-  });
-
-  it("keeps Chrome CDP guard disabled by default with port 15166", () => {
+    expect(sample.cursor?.alternativeModel).toBe("");
+    expect(sample.codex?.alternativeModel).toBe("");
+  });
+
+  it("sets ccc agent DeepSeek defaults in the sample config", () => {
+    const configSamplePath = join(process.cwd(), "config.sample.json");
+    const sample = JSON.parse(readFileSync(configSamplePath, "utf8")) as {
+      ccc?: { DEEPSEEK_API_KEY?: unknown; DEEPSEEK_BASE_URL?: unknown; model?: unknown };
+    };
+
+    expect(sample.ccc?.DEEPSEEK_API_KEY).toBe("");
+    expect(sample.ccc?.DEEPSEEK_BASE_URL).toBe("https://api.deepseek.com/v1");
+    expect(sample.ccc?.model).toBe("deepseek-v4-pro");
+  });
+
+  it("keeps Chrome CDP guard disabled by default with port 15166", () => {
     const configSamplePath = join(process.cwd(), "config.sample.json");
     const sample = JSON.parse(readFileSync(configSamplePath, "utf8")) as {
       chromeDevtools?: { enabled?: unknown; port?: unknown; chromePath?: unknown };
@@ -72,7 +72,7 @@ describe("config.sample.json", () => {
       }>;
     };
 
-    for (const tool of ["claude", "cursor", "codex", "ccc"]) {
+    for (const tool of ["claude", "cursor", "codex", "ccc"]) {
       expect(sample.rawStreamLogs?.[tool]?.enabled).toBe(false);
       expect(sample.rawStreamLogs?.[tool]?.maxBytesPerTurn).toBe(52_428_800);
       expect(sample.rawStreamLogs?.[tool]?.retentionDays).toBe(7);