chatccc 0.2.230 → 0.2.231

package/src/__tests__/startup-lifecycle.test.ts

@@ -1,231 +1,231 @@
-import { describe, expect, it, vi } from "vitest";
-
-import {
-  INTERNAL_RESTART_ENV_VAR,
-  buildWebUiUrl,
-  createServiceLifecycleGuard,
-  createInternalRestartEnv,
-  openWebUiInDefaultBrowser,
-  shouldAutoOpenWebUi,
-} from "../startup-lifecycle.ts";
-
-describe("ChatCCC startup lifecycle", () => {
-  it("opens the Web UI by default for a direct start", () => {
-    expect(shouldAutoOpenWebUi({ env: {} })).toBe(true);
-    expect(shouldAutoOpenWebUi({ env: {}, openOnStart: true })).toBe(true);
-  });
-
-  it("respects the persisted openOnStart preference", () => {
-    expect(shouldAutoOpenWebUi({ env: {}, openOnStart: false })).toBe(false);
-  });
-
-  it("never opens the Web UI for an internal restart", () => {
-    expect(shouldAutoOpenWebUi({
-      env: { [INTERNAL_RESTART_ENV_VAR]: "1" },
-      openOnStart: true,
-    })).toBe(false);
-  });
-
-  it("marks internal restart children without losing the inherited environment", () => {
-    expect(createInternalRestartEnv({ PATH: "test-path", CUSTOM: "value" })).toEqual({
-      PATH: "test-path",
-      CUSTOM: "value",
-      [INTERNAL_RESTART_ENV_VAR]: "1",
-    });
-  });
-
-  it("uses localhost and the configured port for the Web UI URL", () => {
-    expect(buildWebUiUrl(18080)).toBe("http://localhost:18080/");
-    expect(buildWebUiUrl(18081)).toBe("http://localhost:18081/");
-  });
-
-  it("opens the configured URL in the Windows default browser", () => {
-    const child = {
-      on: vi.fn().mockReturnThis(),
-      unref: vi.fn(),
-    };
-    const spawnImpl = vi.fn(() => child as never);
-
-    expect(openWebUiInDefaultBrowser(18081, {
-      platform: "win32",
-      spawnImpl,
-    })).toBe(true);
-    expect(spawnImpl).toHaveBeenCalledWith(
-      "cmd.exe",
-      ["/c", "start", "", "http://localhost:18081/"],
-      {
-        detached: true,
-        stdio: "ignore",
-        windowsHide: true,
-      },
-    );
-    expect(child.on).toHaveBeenCalledWith("error", expect.any(Function));
-    expect(child.unref).toHaveBeenCalledOnce();
-  });
-
-  it("opens the configured URL with xdg-open on a Linux desktop", () => {
-    const child = {
-      on: vi.fn().mockReturnThis(),
-      unref: vi.fn(),
-    };
-    const spawnImpl = vi.fn(() => child as never);
-
-    expect(openWebUiInDefaultBrowser(18080, {
-      platform: "linux",
-      env: { DISPLAY: ":0" },
-      spawnImpl,
-    })).toBe(true);
-    expect(spawnImpl).toHaveBeenCalledWith(
-      "xdg-open",
-      ["http://localhost:18080/"],
-      { detached: true, stdio: "ignore" },
-    );
-  });
-
-  it("skips xdg-open and prints an SSH tunnel hint on headless Linux", () => {
-    const spawnImpl = vi.fn();
-    const onInfo = vi.fn();
-
-    expect(openWebUiInDefaultBrowser(18080, {
-      platform: "linux",
-      env: {},
-      spawnImpl,
-      onInfo,
-    })).toBe(false);
-    expect(spawnImpl).not.toHaveBeenCalled();
-    expect(onInfo).toHaveBeenCalledWith(expect.stringContaining("ssh -L 18080:127.0.0.1:18080"));
-    expect(onInfo).toHaveBeenCalledWith(expect.stringContaining("http://localhost:18080/"));
-  });
-});
-
-describe("ChatCCC service lifecycle guard", () => {
-  function createHarness() {
-    let intervalCallback: (() => void) | undefined;
-    const timer = { ref: vi.fn() };
-    const setIntervalImpl = vi.fn((callback: () => void) => {
-      intervalCallback = callback;
-      return timer;
-    });
-    const clearIntervalImpl = vi.fn();
-    const tracer = vi.fn();
-    const server = {
-      listening: true,
-      address: vi.fn(() => ({ address: "127.0.0.1", port: 18080 })),
-      ref: vi.fn(),
-    };
-    const recoverServer = vi.fn(async () => {
-      server.listening = true;
-    });
-    const guard = createServiceLifecycleGuard({
-      intervalMs: 10_000,
-      setIntervalImpl,
-      clearIntervalImpl,
-      tracer,
-      getActiveResourcesInfo: () => ["TCPServerWrap", "Timeout"],
-    });
-
-    return {
-      clearIntervalImpl,
-      getIntervalCallback: () => intervalCallback,
-      guard,
-      recoverServer,
-      server,
-      setIntervalImpl,
-      timer,
-      tracer,
-    };
-  }
-
-  it("starts exactly one referenced keep-alive timer", () => {
-    const h = createHarness();
-
-    h.guard.start();
-    h.guard.start();
-
-    expect(h.setIntervalImpl).toHaveBeenCalledOnce();
-    expect(h.setIntervalImpl).toHaveBeenCalledWith(expect.any(Function), 10_000);
-    expect(h.timer.ref).toHaveBeenCalledOnce();
-  });
-
-  it("keeps a listening HTTP server referenced", async () => {
-    const h = createHarness();
-    h.guard.attachServer(h.server, h.recoverServer);
-    h.guard.start();
-
-    await h.guard.checkNow();
-
-    expect(h.server.ref).toHaveBeenCalled();
-    expect(h.recoverServer).not.toHaveBeenCalled();
-  });
-
-  it("coalesces concurrent recovery when the HTTP server is not listening", async () => {
-    const h = createHarness();
-    h.server.listening = false;
-    let finishRecovery: (() => void) | undefined;
-    h.recoverServer.mockImplementation(() => new Promise<void>((resolve) => {
-      finishRecovery = () => {
-        h.server.listening = true;
-        resolve();
-      };
-    }));
-    h.guard.attachServer(h.server, h.recoverServer);
-    h.guard.start();
-
-    const first = h.guard.checkNow();
-    const second = h.guard.checkNow();
-    await Promise.resolve();
-    expect(h.recoverServer).toHaveBeenCalledOnce();
-
-    finishRecovery?.();
-    await Promise.all([first, second]);
-    expect(h.tracer).toHaveBeenCalledWith(
-      "service-lifecycle: HTTP server recovered",
-      expect.objectContaining({ serverListening: true }),
-    );
-  });
-
-  it("re-arms on unexpected beforeExit and records public diagnostics", async () => {
-    const h = createHarness();
-    h.guard.attachServer(h.server, h.recoverServer);
-
-    h.guard.handleBeforeExit(0);
-    await h.guard.checkNow();
-
-    expect(h.setIntervalImpl).toHaveBeenCalledOnce();
-    expect(h.server.ref).toHaveBeenCalled();
-    expect(h.tracer).toHaveBeenCalledWith(
-      "service-lifecycle: unexpected beforeExit",
-      expect.objectContaining({
-        code: 0,
-        activeResources: ["TCPServerWrap", "Timeout"],
-        serverListening: true,
-      }),
-    );
-  });
-
-  it("stays stopped after an intentional shutdown", () => {
-    const h = createHarness();
-    h.guard.start();
-
-    h.guard.beginShutdown("SIGTERM");
-    h.guard.handleBeforeExit(0);
-
-    expect(h.clearIntervalImpl).toHaveBeenCalledWith(h.timer);
-    expect(h.setIntervalImpl).toHaveBeenCalledOnce();
-    expect(h.tracer).toHaveBeenCalledWith(
-      "service-lifecycle: shutdown requested",
-      { reason: "SIGTERM" },
-    );
-  });
-
-  it("the timer callback runs a health check", async () => {
-    const h = createHarness();
-    h.guard.attachServer(h.server, h.recoverServer);
-    h.guard.start();
-
-    h.getIntervalCallback()?.();
-    await Promise.resolve();
-
-    expect(h.server.ref).toHaveBeenCalled();
-  });
-});
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  INTERNAL_RESTART_ENV_VAR,
+  buildWebUiUrl,
+  createServiceLifecycleGuard,
+  createInternalRestartEnv,
+  openWebUiInDefaultBrowser,
+  shouldAutoOpenWebUi,
+} from "../startup-lifecycle.ts";
+
+describe("ChatCCC startup lifecycle", () => {
+  it("opens the Web UI by default for a direct start", () => {
+    expect(shouldAutoOpenWebUi({ env: {} })).toBe(true);
+    expect(shouldAutoOpenWebUi({ env: {}, openOnStart: true })).toBe(true);
+  });
+
+  it("respects the persisted openOnStart preference", () => {
+    expect(shouldAutoOpenWebUi({ env: {}, openOnStart: false })).toBe(false);
+  });
+
+  it("never opens the Web UI for an internal restart", () => {
+    expect(shouldAutoOpenWebUi({
+      env: { [INTERNAL_RESTART_ENV_VAR]: "1" },
+      openOnStart: true,
+    })).toBe(false);
+  });
+
+  it("marks internal restart children without losing the inherited environment", () => {
+    expect(createInternalRestartEnv({ PATH: "test-path", CUSTOM: "value" })).toEqual({
+      PATH: "test-path",
+      CUSTOM: "value",
+      [INTERNAL_RESTART_ENV_VAR]: "1",
+    });
+  });
+
+  it("uses localhost and the configured port for the Web UI URL", () => {
+    expect(buildWebUiUrl(18080)).toBe("http://localhost:18080/");
+    expect(buildWebUiUrl(18081)).toBe("http://localhost:18081/");
+  });
+
+  it("opens the configured URL in the Windows default browser", () => {
+    const child = {
+      on: vi.fn().mockReturnThis(),
+      unref: vi.fn(),
+    };
+    const spawnImpl = vi.fn(() => child as never);
+
+    expect(openWebUiInDefaultBrowser(18081, {
+      platform: "win32",
+      spawnImpl,
+    })).toBe(true);
+    expect(spawnImpl).toHaveBeenCalledWith(
+      "cmd.exe",
+      ["/c", "start", "", "http://localhost:18081/"],
+      {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+      },
+    );
+    expect(child.on).toHaveBeenCalledWith("error", expect.any(Function));
+    expect(child.unref).toHaveBeenCalledOnce();
+  });
+
+  it("opens the configured URL with xdg-open on a Linux desktop", () => {
+    const child = {
+      on: vi.fn().mockReturnThis(),
+      unref: vi.fn(),
+    };
+    const spawnImpl = vi.fn(() => child as never);
+
+    expect(openWebUiInDefaultBrowser(18080, {
+      platform: "linux",
+      env: { DISPLAY: ":0" },
+      spawnImpl,
+    })).toBe(true);
+    expect(spawnImpl).toHaveBeenCalledWith(
+      "xdg-open",
+      ["http://localhost:18080/"],
+      { detached: true, stdio: "ignore" },
+    );
+  });
+
+  it("skips xdg-open and prints an SSH tunnel hint on headless Linux", () => {
+    const spawnImpl = vi.fn();
+    const onInfo = vi.fn();
+
+    expect(openWebUiInDefaultBrowser(18080, {
+      platform: "linux",
+      env: {},
+      spawnImpl,
+      onInfo,
+    })).toBe(false);
+    expect(spawnImpl).not.toHaveBeenCalled();
+    expect(onInfo).toHaveBeenCalledWith(expect.stringContaining("ssh -L 18080:127.0.0.1:18080"));
+    expect(onInfo).toHaveBeenCalledWith(expect.stringContaining("http://localhost:18080/"));
+  });
+});
+
+describe("ChatCCC service lifecycle guard", () => {
+  function createHarness() {
+    let intervalCallback: (() => void) | undefined;
+    const timer = { ref: vi.fn() };
+    const setIntervalImpl = vi.fn((callback: () => void) => {
+      intervalCallback = callback;
+      return timer;
+    });
+    const clearIntervalImpl = vi.fn();
+    const tracer = vi.fn();
+    const server = {
+      listening: true,
+      address: vi.fn(() => ({ address: "127.0.0.1", port: 18080 })),
+      ref: vi.fn(),
+    };
+    const recoverServer = vi.fn(async () => {
+      server.listening = true;
+    });
+    const guard = createServiceLifecycleGuard({
+      intervalMs: 10_000,
+      setIntervalImpl,
+      clearIntervalImpl,
+      tracer,
+      getActiveResourcesInfo: () => ["TCPServerWrap", "Timeout"],
+    });
+
+    return {
+      clearIntervalImpl,
+      getIntervalCallback: () => intervalCallback,
+      guard,
+      recoverServer,
+      server,
+      setIntervalImpl,
+      timer,
+      tracer,
+    };
+  }
+
+  it("starts exactly one referenced keep-alive timer", () => {
+    const h = createHarness();
+
+    h.guard.start();
+    h.guard.start();
+
+    expect(h.setIntervalImpl).toHaveBeenCalledOnce();
+    expect(h.setIntervalImpl).toHaveBeenCalledWith(expect.any(Function), 10_000);
+    expect(h.timer.ref).toHaveBeenCalledOnce();
+  });
+
+  it("keeps a listening HTTP server referenced", async () => {
+    const h = createHarness();
+    h.guard.attachServer(h.server, h.recoverServer);
+    h.guard.start();
+
+    await h.guard.checkNow();
+
+    expect(h.server.ref).toHaveBeenCalled();
+    expect(h.recoverServer).not.toHaveBeenCalled();
+  });
+
+  it("coalesces concurrent recovery when the HTTP server is not listening", async () => {
+    const h = createHarness();
+    h.server.listening = false;
+    let finishRecovery: (() => void) | undefined;
+    h.recoverServer.mockImplementation(() => new Promise<void>((resolve) => {
+      finishRecovery = () => {
+        h.server.listening = true;
+        resolve();
+      };
+    }));
+    h.guard.attachServer(h.server, h.recoverServer);
+    h.guard.start();
+
+    const first = h.guard.checkNow();
+    const second = h.guard.checkNow();
+    await Promise.resolve();
+    expect(h.recoverServer).toHaveBeenCalledOnce();
+
+    finishRecovery?.();
+    await Promise.all([first, second]);
+    expect(h.tracer).toHaveBeenCalledWith(
+      "service-lifecycle: HTTP server recovered",
+      expect.objectContaining({ serverListening: true }),
+    );
+  });
+
+  it("re-arms on unexpected beforeExit and records public diagnostics", async () => {
+    const h = createHarness();
+    h.guard.attachServer(h.server, h.recoverServer);
+
+    h.guard.handleBeforeExit(0);
+    await h.guard.checkNow();
+
+    expect(h.setIntervalImpl).toHaveBeenCalledOnce();
+    expect(h.server.ref).toHaveBeenCalled();
+    expect(h.tracer).toHaveBeenCalledWith(
+      "service-lifecycle: unexpected beforeExit",
+      expect.objectContaining({
+        code: 0,
+        activeResources: ["TCPServerWrap", "Timeout"],
+        serverListening: true,
+      }),
+    );
+  });
+
+  it("stays stopped after an intentional shutdown", () => {
+    const h = createHarness();
+    h.guard.start();
+
+    h.guard.beginShutdown("SIGTERM");
+    h.guard.handleBeforeExit(0);
+
+    expect(h.clearIntervalImpl).toHaveBeenCalledWith(h.timer);
+    expect(h.setIntervalImpl).toHaveBeenCalledOnce();
+    expect(h.tracer).toHaveBeenCalledWith(
+      "service-lifecycle: shutdown requested",
+      { reason: "SIGTERM" },
+    );
+  });
+
+  it("the timer callback runs a health check", async () => {
+    const h = createHarness();
+    h.guard.attachServer(h.server, h.recoverServer);
+    h.guard.start();
+
+    h.getIntervalCallback()?.();
+    await Promise.resolve();
+
+    expect(h.server.ref).toHaveBeenCalled();
+  });
+});

package/src/__tests__/stop-session.test.ts

@@ -11,15 +11,15 @@ import { describe, it, expect, vi, beforeEach } from "vitest";
 import type { StreamState } from "../stream-state.ts";
 
 // mock stream-state，使用模块内可观测的 Map 记录读写
-const stateStore = new Map<string, StreamState>();
-const writeCalls: StreamState[] = [];
-const killProcessTreeMock = vi.hoisted(() => vi.fn(async (_pid?: number) => {}));
-
-vi.mock("../adapters/proc-tree-kill.ts", () => ({
-  killProcessTree: killProcessTreeMock,
-}));
-
-vi.mock("../stream-state.ts", () => ({
+const stateStore = new Map<string, StreamState>();
+const writeCalls: StreamState[] = [];
+const killProcessTreeMock = vi.hoisted(() => vi.fn(async (_pid?: number) => {}));
+
+vi.mock("../adapters/proc-tree-kill.ts", () => ({
+  killProcessTree: killProcessTreeMock,
+}));
+
+vi.mock("../stream-state.ts", () => ({
   readStreamState: async (sid: string): Promise<StreamState | null> => {
     return stateStore.get(sid) ?? null;
   },
@@ -77,10 +77,10 @@ async function flush(): Promise<void> {
 }
 
 beforeEach(() => {
-  activePrompts.clear();
-  stateStore.clear();
-  writeCalls.length = 0;
-  killProcessTreeMock.mockClear();
+  activePrompts.clear();
+  stateStore.clear();
+  writeCalls.length = 0;
+  killProcessTreeMock.mockClear();
 });
 
 describe("stopSession 行为护栏", () => {
@@ -134,29 +134,29 @@ describe("stopSession 行为护栏", () => {
     expect(activePrompts.get("sid-C")?.stopped).toBe(true);
   });
 
-  it("调用 adapter 提供的 closeSession 以主动关闭底层 SDK session", () => {
+  it("调用 adapter 提供的 closeSession 以主动关闭底层 SDK session", () => {
     const closeSession = vi.fn();
     seedRunningSession("sid-D", "partial output", closeSession);
 
     const ok = stopSession("sid-D");
 
-    expect(ok).toBe(true);
-    expect(closeSession).toHaveBeenCalledTimes(1);
-  });
-
-  it("按完整进程树停止 CLI，不先杀壳进程造成后代进程逃逸", async () => {
-    seedRunningSession("sid-tree");
-    activePrompts.get("sid-tree")!.processPid = 4242;
-    const processKillSpy = vi.spyOn(process, "kill").mockImplementation(() => true);
-
-    try {
-      expect(stopSession("sid-tree")).toBe(true);
-      await flush();
-
-      expect(killProcessTreeMock).toHaveBeenCalledWith(4242);
-      expect(processKillSpy).not.toHaveBeenCalled();
-    } finally {
-      processKillSpy.mockRestore();
-    }
-  });
-});
+    expect(ok).toBe(true);
+    expect(closeSession).toHaveBeenCalledTimes(1);
+  });
+
+  it("按完整进程树停止 CLI，不先杀壳进程造成后代进程逃逸", async () => {
+    seedRunningSession("sid-tree");
+    activePrompts.get("sid-tree")!.processPid = 4242;
+    const processKillSpy = vi.spyOn(process, "kill").mockImplementation(() => true);
+
+    try {
+      expect(stopSession("sid-tree")).toBe(true);
+      await flush();
+
+      expect(killProcessTreeMock).toHaveBeenCalledWith(4242);
+      expect(processKillSpy).not.toHaveBeenCalled();
+    } finally {
+      processKillSpy.mockRestore();
+    }
+  });
+});

package/src/__tests__/stream-state.test.ts

@@ -15,12 +15,12 @@ vi.mock("../config.ts", async () => {
 });
 
 const {
-  writeStreamState,
-  readStreamState,
-  createEmptyStreamState,
-  isFinalReplySentForTurn,
-  markFinalReplySent,
-  STREAMS_DIR,
+  writeStreamState,
+  readStreamState,
+  createEmptyStreamState,
+  isFinalReplySentForTurn,
+  markFinalReplySent,
+  STREAMS_DIR,
   _setRenameForTest,
   _resetRenameForTest,
 } = await import("../stream-state.ts");
@@ -119,36 +119,36 @@ describe("writeStreamState — atomic rename", () => {
     const got = await readStreamState("never-existed");
     expect(got).toBeNull();
   });
-  it("marks final reply delivery for the matching terminal turn only", async () => {
-    const state = createEmptyStreamState("sid-delivered", "/tmp", "claude", 2);
-    state.status = "done";
-    state.finalReply = "done";
-    await writeStreamState(state);
-
-    await markFinalReplySent("sid-delivered", 2, 12345);
-
-    const got = await readStreamState("sid-delivered");
-    expect(got).not.toBeNull();
-    expect(got!.finalReplySentTurn).toBe(2);
-    expect(got!.finalReplySentAt).toBe(12345);
-    expect(isFinalReplySentForTurn(got!)).toBe(true);
-  });
-
-  it("does not mark a running state or a different turn as delivered", async () => {
-    const state = createEmptyStreamState("sid-running", "/tmp", "claude", 3);
-    await writeStreamState(state);
-
-    await markFinalReplySent("sid-running", 2, 12345);
-    await markFinalReplySent("sid-running", 3, 12345);
-
-    const got = await readStreamState("sid-running");
-    expect(got).not.toBeNull();
-    expect(got!.finalReplySentTurn).toBeUndefined();
-    expect(isFinalReplySentForTurn(got!)).toBe(false);
-  });
-});
-
-describe("createEmptyStreamState", () => {
+  it("marks final reply delivery for the matching terminal turn only", async () => {
+    const state = createEmptyStreamState("sid-delivered", "/tmp", "claude", 2);
+    state.status = "done";
+    state.finalReply = "done";
+    await writeStreamState(state);
+
+    await markFinalReplySent("sid-delivered", 2, 12345);
+
+    const got = await readStreamState("sid-delivered");
+    expect(got).not.toBeNull();
+    expect(got!.finalReplySentTurn).toBe(2);
+    expect(got!.finalReplySentAt).toBe(12345);
+    expect(isFinalReplySentForTurn(got!)).toBe(true);
+  });
+
+  it("does not mark a running state or a different turn as delivered", async () => {
+    const state = createEmptyStreamState("sid-running", "/tmp", "claude", 3);
+    await writeStreamState(state);
+
+    await markFinalReplySent("sid-running", 2, 12345);
+    await markFinalReplySent("sid-running", 3, 12345);
+
+    const got = await readStreamState("sid-running");
+    expect(got).not.toBeNull();
+    expect(got!.finalReplySentTurn).toBeUndefined();
+    expect(isFinalReplySentForTurn(got!)).toBe(false);
+  });
+});
+
+describe("createEmptyStreamState", () => {
   it("生成的 state 字段正确且 status=running", () => {
     const s = createEmptyStreamState("sid-X", "/cwd", "cursor", 5);
     expect(s.sessionId).toBe("sid-X");
@@ -156,9 +156,9 @@ describe("createEmptyStreamState", () => {
     expect(s.tool).toBe("cursor");
     expect(s.turnCount).toBe(5);
     expect(s.status).toBe("running");
-    expect(s.accumulatedContent).toBe("");
-    expect(s.finalReply).toBe("");
-    expect(s.finalReplySentTurn).toBeUndefined();
-    expect(s.chunkCount).toBe(0);
-  });
-});
+    expect(s.accumulatedContent).toBe("");
+    expect(s.finalReply).toBe("");
+    expect(s.finalReplySentTurn).toBeUndefined();
+    expect(s.chunkCount).toBe(0);
+  });
+});