chatccc 0.2.252 → 0.2.254

package/src/__tests__/simplify.test.ts

@@ -1,283 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, afterAll, vi } from "vitest";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-const TEST_DATA_DIR = await mkdtemp(join(tmpdir(), "chatccc-simplify-test-"));
-vi.mock("../config.ts", async () => {
-  const actual = await vi.importActual<typeof import("../config.ts")>("../config.ts");
-  return {
-    ...actual,
-    PROJECT_ROOT: TEST_DATA_DIR,
-    ts: () => "test-ts",
-  };
-});
-
-let simplifyToolUse: (name: string, input: unknown) => string | null;
-let simplifyToolResult: (name: string, toolUseId: string, isError: boolean, toolCallInput?: unknown) => string | null;
-let reloadSimplifyConfig: () => void;
-
-beforeEach(async () => {
-  vi.resetModules();
-  try {
-    await rm(join(TEST_DATA_DIR, "simplify.json"), { force: true });
-  } catch {}
-  const mod = await import("../simplify.ts");
-  simplifyToolUse = mod.simplifyToolUse;
-  simplifyToolResult = mod.simplifyToolResult;
-  reloadSimplifyConfig = mod.reloadSimplifyConfig;
-});
-
-afterAll(async () => {
-  try {
-    await rm(TEST_DATA_DIR, { recursive: true, force: true });
-  } catch {}
-});
-
-describe("simplifyToolUse", () => {
-  it("无 simplify.json 时返回 null（回退默认格式化）", () => {
-    reloadSimplifyConfig();
-    expect(simplifyToolUse("Read", { file_path: "/tmp/x.ts" })).toBeNull();
-  });
-
-  it("有规则时按模板格式化 tool_use", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "simplify.json"),
-      JSON.stringify({
-        tool_use: {
-          Read: { template: "📖 **Read** {file_path}", maxLength: 300 },
-        },
-      }),
-      "utf-8",
-    );
-    reloadSimplifyConfig();
-
-    expect(simplifyToolUse("Read", { file_path: "/home/user/project/src/index.ts" }))
-      .toBe("📖 **Read** /home/user/project/src/index.ts");
-  });
-
-  it("无对应工具规则时返回 null", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "simplify.json"),
-      JSON.stringify({
-        tool_use: {
-          Read: { template: "📖 **Read** {file_path}", maxLength: 300 },
-        },
-      }),
-      "utf-8",
-    );
-    reloadSimplifyConfig();
-
-    expect(simplifyToolUse("Write", { file_path: "/tmp/x.ts" })).toBeNull();
-  });
-
-  it("模板中未匹配的占位符保留原文", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "simplify.json"),
-      JSON.stringify({
-        tool_use: {
-          Read: { template: "📖 **Read** {file_path} {unknown_field}", maxLength: 300 },
-        },
-      }),
-      "utf-8",
-    );
-    reloadSimplifyConfig();
-
-    expect(simplifyToolUse("Read", { file_path: "/tmp/x.ts" }))
-      .toBe("📖 **Read** /tmp/x.ts {unknown_field}");
-  });
-
-  it("超过 maxLength 时截断", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "simplify.json"),
-      JSON.stringify({
-        tool_use: {
-          Bash: { template: "🖥️ **Bash** {command}", maxLength: 20 },
-        },
-      }),
-      "utf-8",
-    );
-    reloadSimplifyConfig();
-
-    const result = simplifyToolUse("Bash", { command: "echo hello world this is a long command" });
-    expect(result).toBeTruthy();
-    // 被截断了：长度不超过 maxLength + 3（"..." 后缀）
-    expect(result!.length).toBeLessThanOrEqual(23);
-    expect(result!.endsWith("...")).toBe(true);
-  });
-
-  it("多字段模板", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "simplify.json"),
-      JSON.stringify({
-        tool_use: {
-          Grep: { template: "🔎 **Grep** {pattern} in {path}", maxLength: 300 },
-        },
-      }),
-      "utf-8",
-    );
-    reloadSimplifyConfig();
-
-    expect(simplifyToolUse("Grep", { pattern: "TODO", path: "src/" }))
-      .toBe("🔎 **Grep** TODO in src/");
-  });
-
-  it("input 为 null 时不抛异常", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "simplify.json"),
-      JSON.stringify({
-        tool_use: {
-          TodoWrite: { template: "✅ **TodoWrite**", maxLength: 200 },
-        },
-      }),
-      "utf-8",
-    );
-    reloadSimplifyConfig();
-
-    expect(simplifyToolUse("TodoWrite", null)).toBe("✅ **TodoWrite**");
-  });
-});
-
-describe("simplifyToolResult", () => {
-  it("无 simplify.json 时返回 null", () => {
-    reloadSimplifyConfig();
-    expect(simplifyToolResult("Read", "abc123def456", false)).toBeNull();
-  });
-
-  it("有规则时按模板格式化 tool_result", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "simplify.json"),
-      JSON.stringify({
-        tool_result: {
-          Read: { template: "✅ *{id}*: 已读取", maxLength: 200 },
-        },
-      }),
-      "utf-8",
-    );
-    reloadSimplifyConfig();
-
-    expect(simplifyToolResult("Read", "abc123def456", false))
-      .toBe("✅ *def456*: 已读取");
-  });
-
-  it("isError 时结果前加 ❌", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "simplify.json"),
-      JSON.stringify({
-        tool_result: {
-          Read: { template: "✅ *{id}*: 已读取", maxLength: 200 },
-        },
-      }),
-      "utf-8",
-    );
-    reloadSimplifyConfig();
-
-    expect(simplifyToolResult("Read", "abc123def456", true))
-      .toBe("❌ ✅ *def456*: 已读取");
-  });
-
-  it("tool_result 模板可使用 tool_use 的输入字段", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "simplify.json"),
-      JSON.stringify({
-        tool_result: {
-          Write: { template: "✅ *{id}*: 已写入 {file_path}", maxLength: 200 },
-        },
-      }),
-      "utf-8",
-    );
-    reloadSimplifyConfig();
-
-    expect(simplifyToolResult("Write", "abc123def456", false, { file_path: "/tmp/out.txt" }))
-      .toBe("✅ *def456*: 已写入 /tmp/out.txt");
-  });
-
-  it("无对应工具规则时返回 null", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "simplify.json"),
-      JSON.stringify({
-        tool_result: {
-          Read: { template: "✅ *{id}*: 已读取", maxLength: 200 },
-        },
-      }),
-      "utf-8",
-    );
-    reloadSimplifyConfig();
-
-    expect(simplifyToolResult("Write", "abc123def456", false)).toBeNull();
-  });
-});
-
-describe("accumulateBlockContent with simplification", () => {
-  it("tool_use 使用简化规则，tool_result 回退默认格式", async () => {
-    // 动态 import session 以使用当前 mock 的简单化模块
-    const { accumulateBlockContent } = await import("../session.ts");
-
-    await writeFile(
-      join(TEST_DATA_DIR, "simplify.json"),
-      JSON.stringify({
-        tool_use: {
-          Read: { template: "📖 **Read** {file_path}", maxLength: 300 },
-        },
-      }),
-      "utf-8",
-    );
-    reloadSimplifyConfig();
-
-    const state = { accumulatedContent: "", finalText: "", finalCompleteText: "", chunkCount: 0 };
-    const toolCallMap = new Map<string, { name: string; input: unknown }>();
-
-    accumulateBlockContent(
-      { type: "tool_use", id: "toolu_001", name: "Read", input: { file_path: "/src/app.ts" } },
-      state,
-      toolCallMap,
-    );
-
-    expect(state.accumulatedContent).toBe("\n\n📖 **Read** /src/app.ts\n");
-  });
-
-  it("无简化规则时回退默认 tool_use 格式", async () => {
-    const { accumulateBlockContent: acb } = await import("../session.ts");
-
-    reloadSimplifyConfig(); // 无 simplify.json
-
-    const state = { accumulatedContent: "", finalText: "", finalCompleteText: "", chunkCount: 0 };
-    const toolCallMap = new Map<string, { name: string; input: unknown }>();
-
-    acb(
-      { type: "tool_use", id: "toolu_001", name: "Read", input: { file_path: "/src/app.ts" } },
-      state,
-      toolCallMap,
-    );
-
-    expect(state.accumulatedContent).toContain("📖 **Read**");
-    expect(state.accumulatedContent).toContain('{"file_path":"/src/app.ts"}');
-  });
-
-  it("tool_result 使用简化规则", async () => {
-    const { accumulateBlockContent: acb } = await import("../session.ts");
-
-    await writeFile(
-      join(TEST_DATA_DIR, "simplify.json"),
-      JSON.stringify({
-        tool_result: {
-          Read: { template: "✅ *{id}*: 已读取 {file_path}", maxLength: 200 },
-        },
-      }),
-      "utf-8",
-    );
-    reloadSimplifyConfig();
-
-    const state = { accumulatedContent: "", finalText: "", finalCompleteText: "", chunkCount: 0 };
-    const toolCallMap = new Map<string, { name: string; input: unknown }>();
-    toolCallMap.set("toolu_001", { name: "Read", input: { file_path: "/src/app.ts" } });
-
-    acb(
-      { type: "tool_result", tool_use_id: "toolu_001", content: "file content here..." },
-      state,
-      toolCallMap,
-    );
-
-    expect(state.accumulatedContent).toBe("✅ *lu_001*: 已读取 /src/app.ts\n");
-  });
-});

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

@@ -1,231 +0,0 @@
-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

@@ -1,162 +0,0 @@
-// =============================================================================
-// stop-session.test.ts — stopSession 单测护栏
-// =============================================================================
-// 覆盖修复"幽灵 codex 会话"的两条关键行为：
-// 1) controller.abort() 必须被触发（让 adapter finally 走 killProcessTree）
-// 2) 立刻把 stream-state.status 改成 stopped，不依赖 runAgentSession 的 finally
-//    （那个 finally 要等 generator 自然结束，子进程没死透就一直停在 running）
-// =============================================================================
-
-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", () => ({
-  readStreamState: async (sid: string): Promise<StreamState | null> => {
-    return stateStore.get(sid) ?? null;
-  },
-  writeStreamState: async (state: StreamState): Promise<void> => {
-    writeCalls.push(structuredClone(state));
-    stateStore.set(state.sessionId, state);
-  },
-  createEmptyStreamState: (sid: string, cwd: string, tool: string, turnCount: number) => ({
-    sessionId: sid,
-    status: "running" as const,
-    accumulatedContent: "",
-    finalReply: "",
-    chunkCount: 0,
-    turnCount,
-    contextTokens: 0,
-    updatedAt: Date.now(),
-    cwd,
-    tool,
-  }),
-  fixStaleStreamStates: async () => {},
-  STREAMS_DIR: "/tmp/streams-mock",
-}));
-
-import { stopSession } from "../session.ts";
-import { activePrompts } from "../session-chat-binding.ts";
-
-function seedRunningSession(
-  sid: string,
-  accumulated = "partial output",
-  closeSession?: () => void,
-): AbortController {
-  const controller = new AbortController();
-  activePrompts.set(sid, { controller, stopped: false, startTime: Date.now(), closeSession });
-  stateStore.set(sid, {
-    sessionId: sid,
-    status: "running",
-    accumulatedContent: accumulated,
-    finalReply: "",
-    chunkCount: 1,
-    turnCount: 1,
-    contextTokens: 0,
-    updatedAt: Date.now(),
-    cwd: "F:/repo",
-    tool: "codex",
-  });
-  return controller;
-}
-
-async function flush(): Promise<void> {
-  // 让 stopSession 内 fire-and-forget 的 microtask 跑完
-  for (let i = 0; i < 5; i++) {
-    await Promise.resolve();
-  }
-  await new Promise((r) => setTimeout(r, 10));
-}
-
-beforeEach(() => {
-  activePrompts.clear();
-  stateStore.clear();
-  writeCalls.length = 0;
-  killProcessTreeMock.mockClear();
-});
-
-describe("stopSession 行为护栏", () => {
-  it("没有活跃 session 时返回 false，不做任何事", async () => {
-    const ok = stopSession("nonexistent");
-    expect(ok).toBe(false);
-    await flush();
-    expect(writeCalls).toHaveLength(0);
-  });
-
-  it("abort controller + 立刻把 stream-state.status 写成 stopped", async () => {
-    const controller = seedRunningSession("sid-A", "hello world");
-    let aborted = false;
-    controller.signal.addEventListener("abort", () => { aborted = true; });
-
-    const ok = stopSession("sid-A");
-    expect(ok).toBe(true);
-    expect(aborted).toBe(true);
-
-    await flush();
-
-    // 关键护栏：必须有一次 writeStreamState 把 status 改成 stopped
-    expect(writeCalls.length).toBeGreaterThanOrEqual(1);
-    const lastWrite = writeCalls[writeCalls.length - 1];
-    expect(lastWrite.sessionId).toBe("sid-A");
-    expect(lastWrite.status).toBe("stopped");
-    // 累积内容不丢
-    expect(lastWrite.accumulatedContent).toBe("hello world");
-  });
-
-  it("已经是终态(done/stopped/error)的 stream-state 不会被覆盖", async () => {
-    seedRunningSession("sid-B");
-    // 模拟 generator finally 已经先写了 done
-    stateStore.set("sid-B", {
-      ...stateStore.get("sid-B")!,
-      status: "done",
-    });
-
-    const ok = stopSession("sid-B");
-    expect(ok).toBe(true);
-    await flush();
-
-    // 不应再有 stopped 覆盖 done 的写入
-    const stoppedWrites = writeCalls.filter((w) => w.status === "stopped");
-    expect(stoppedWrites).toHaveLength(0);
-  });
-
-  it("activePrompts 标记 stopped=true", async () => {
-    seedRunningSession("sid-C");
-    stopSession("sid-C");
-    expect(activePrompts.get("sid-C")?.stopped).toBe(true);
-  });
-
-  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();
-    }
-  });
-});