chatccc 0.2.252 → 0.2.254

package/src/__tests__/package-files.test.ts

@@ -1,24 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-
-import { describe, expect, it } from "vitest";
-
-const CREATE_APP_SKILL_DIRS = [
-  ".agents/skills/create-chatccc-feishu-app/",
-  ".claude/skills/create-chatccc-feishu-app/",
-  ".cursor/skills/create-chatccc-feishu-app/",
-];
-
-describe("npm package files", () => {
-  it("ships the Feishu app creation skill for every supported agent", () => {
-    const root = process.cwd();
-    const packageJson = JSON.parse(readFileSync(join(root, "package.json"), "utf8")) as {
-      files?: string[];
-    };
-
-    for (const skillDir of CREATE_APP_SKILL_DIRS) {
-      expect(packageJson.files).toContain(skillDir);
-      expect(existsSync(join(root, skillDir, "SKILL.md"))).toBe(true);
-    }
-  });
-});

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

@@ -1,19 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { buildPlatformStartupPlan } from "../platform-startup.ts";
-
-describe("buildPlatformStartupPlan", () => {
-  it("starts WeChat iLink without requiring Feishu when Feishu is disabled", () => {
-    expect(buildPlatformStartupPlan({ feishuEnabled: false, ilinkEnabled: true })).toEqual({
-      startFeishu: false,
-      startIlink: true,
-    });
-  });
-
-  it("can start both platforms when both are enabled", () => {
-    expect(buildPlatformStartupPlan({ feishuEnabled: true, ilinkEnabled: true })).toEqual({
-      startFeishu: true,
-      startIlink: true,
-    });
-  });
-});

package/src/__tests__/privacy.test.ts

@@ -1,198 +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-privacy-test-"));
-vi.mock("../config.ts", async () => {
-  const actual = await vi.importActual<typeof import("../config.ts")>("../config.ts");
-  return {
-    ...actual,
-    USER_DATA_DIR: TEST_DATA_DIR,
-    ts: () => "test-ts",
-  };
-});
-
-let applyPrivacy: (text: string) => string;
-let reloadPrivacyRules: () => void;
-let getPrivacyRules: () => Record<string, string>;
-let getPrivacyConfig: () => { enabled: boolean; rules: Record<string, string> };
-
-beforeEach(async () => {
-  vi.resetModules();
-  try {
-    await rm(join(TEST_DATA_DIR, "privacy.json"), { force: true });
-  } catch {}
-  const mod = await import("../privacy.ts");
-  applyPrivacy = mod.applyPrivacy;
-  reloadPrivacyRules = mod.reloadPrivacyRules;
-  getPrivacyRules = mod.getPrivacyRules;
-  getPrivacyConfig = mod.getPrivacyConfig;
-});
-
-afterEach(async () => {
-  try {
-    await rm(join(TEST_DATA_DIR, "privacy.json"), { force: true });
-  } catch {}
-});
-
-afterAll(async () => {
-  try {
-    await rm(TEST_DATA_DIR, { recursive: true, force: true });
-  } catch {}
-});
-
-describe("applyPrivacy", () => {
-  it("returns original text when privacy.json is missing", () => {
-    reloadPrivacyRules();
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
-  });
-
-  it("supports legacy flat privacy rules", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ weizhangjian: "wzj", secret: "***" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello wzj");
-    expect(applyPrivacy("my secret is safe")).toBe("my *** is safe");
-    expect(applyPrivacy("weizhangjian and secret")).toBe("wzj and ***");
-  });
-
-  it("supports privacy.json schema with enabled=false", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ enabled: false, rules: { weizhangjian: "wzj" } }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(getPrivacyConfig()).toEqual({ enabled: false, rules: { weizhangjian: "wzj" } });
-    expect(getPrivacyRules()).toEqual({ weizhangjian: "wzj" });
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
-  });
-
-  it("supports privacy.json schema with enabled=true", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ enabled: true, rules: { weizhangjian: "wzj" } }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello wzj");
-  });
-
-  it("accepts UTF-8 BOM in privacy.json", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      `\uFEFF${JSON.stringify({ enabled: false, rules: { weizhangjian: "wzj" } })}`,
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(getPrivacyConfig()).toEqual({ enabled: false, rules: { weizhangjian: "wzj" } });
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
-  });
-
-  it("auto reloads privacy.json changes without explicit reload", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ weizhangjian: "wzj" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello wzj");
-
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ enabled: false, rules: { weizhangjian: "wzj-disabled" } }),
-      "utf-8",
-    );
-
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
-    expect(getPrivacyConfig()).toEqual({ enabled: false, rules: { weizhangjian: "wzj-disabled" } });
-  });
-
-  it("replaces multiple rules and repeated occurrences", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ a: "A", b: "B" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("a b a b")).toBe("A B A B");
-  });
-
-  it("returns empty text directly", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ x: "y" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("")).toBe("");
-  });
-
-  it("treats special characters in rule keys literally", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ "a.b": "X", "(test)": "Y", "*star": "Z" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello a.b world")).toBe("hello X world");
-    expect(applyPrivacy("text (test) here")).toBe("text Y here");
-    expect(applyPrivacy("a *star shines")).toBe("a Z shines");
-  });
-
-  it("reloadPrivacyRules forces a reload", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ old: "OLD" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("old")).toBe("OLD");
-    expect(getPrivacyRules()).toEqual({ old: "OLD" });
-
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify({ new: "NEW" }),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("new")).toBe("NEW");
-    expect(getPrivacyRules()).toEqual({ new: "NEW" });
-  });
-
-  it("returns original text for malformed JSON", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      "not json",
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello")).toBe("hello");
-  });
-
-  it("returns original text for array JSON", async () => {
-    await writeFile(
-      join(TEST_DATA_DIR, "privacy.json"),
-      JSON.stringify(["a", "b"]),
-      "utf-8",
-    );
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello")).toBe("hello");
-  });
-});

package/src/__tests__/proc-tree-kill.test.ts

@@ -1,108 +0,0 @@
-// =============================================================================
-// proc-tree-kill.test.ts — 进程树强杀工具单测护栏
-// =============================================================================
-// 目的：覆盖 codex/cursor adapter 之前 proc.kill() 在 Windows + shell:true 下
-//      只杀第一层 cmd.exe 壳、留下 node + 真二进制成"幽灵"的 bug。
-// 测试构造一棵三层进程树（祖父 cmd/sh → 父 node → 子 sleep 进程），
-// 用 killProcessTree 杀掉祖父 PID，断言整棵树都不存在了。
-// =============================================================================
-
-import { describe, it, expect } from "vitest";
-import { spawn } from "node:child_process";
-import { join } from "node:path";
-import { writeFileSync, unlinkSync, existsSync, mkdtempSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { killProcessTree } from "../adapters/proc-tree-kill.ts";
-
-function isAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function sleep(ms: number): Promise<void> {
-  await new Promise((r) => setTimeout(r, ms));
-}
-
-describe("killProcessTree", () => {
-  it("kills a 3-level process tree (shell wrapper + node child + node grandchild)", async () => {
-    // 用临时脚本模拟 codex CLI 的真实拓扑：
-    //   layer-1: shell (cmd.exe / sh) — 因为 spawn 用了 shell:true
-    //     layer-2: node 进程 — 模拟 `node codex.js` 入口
-    //       layer-3: 又一个 node 进程 — 模拟真正干活的 codex.exe 子进程
-    const tmp = mkdtempSync(join(tmpdir(), "chatccc-proctree-"));
-    const childScript = join(tmp, "child.mjs");
-    const pidFile = join(tmp, "grand.pid");
-    const isWin = process.platform === "win32";
-
-    writeFileSync(
-      childScript,
-      [
-        `import { spawn } from "node:child_process";`,
-        `import { writeFileSync } from "node:fs";`,
-        // 启动孙进程：再开一个 node，跑一个 10 分钟的 setTimeout 占位
-        `const grand = spawn(process.execPath, ["-e", "setTimeout(()=>{},600000)"], { stdio: "ignore", detached: false });`,
-        `writeFileSync(${JSON.stringify(pidFile)}, String(grand.pid));`,
-        // 父进程自己也挂住别退出
-        `setTimeout(()=>{}, 600000);`,
-      ].join("\n"),
-      "utf8",
-    );
-
-    // 启动祖父：复现 codex-adapter 用 shell:true 的方式
-    // 路径必须加引号，否则 cmd.exe 把空格当分隔符
-    const proc = spawn(`"${process.execPath}" "${childScript}"`, {
-      stdio: "ignore",
-      shell: true,
-      windowsHide: true,
-      detached: !isWin,
-    });
-
-    expect(proc.pid).toBeGreaterThan(0);
-
-    // 等待孙进程 pid 被写出来（pidFile 出现表示中间 node 已成功 spawn 孙子）
-    let grandPid = 0;
-    for (let i = 0; i < 100; i++) {
-      if (existsSync(pidFile)) {
-        const s = readFileSync(pidFile, "utf8").trim();
-        if (s && /^\d+$/.test(s)) {
-          grandPid = parseInt(s, 10);
-          break;
-        }
-      }
-      await sleep(100);
-    }
-    expect(grandPid).toBeGreaterThan(0);
-    expect(isAlive(grandPid)).toBe(true);
-
-    // 杀祖父（在 shell:true 时 proc.pid 就是 cmd.exe / sh 那一层）。
-    // 关键断言：如果 killProcessTree 没有 /T 递归，grandPid 会留下来。
-    await killProcessTree(proc.pid!);
-
-    for (let i = 0; i < 50; i++) {
-      if (!isAlive(grandPid)) break;
-      await sleep(100);
-    }
-
-    expect(isAlive(grandPid)).toBe(false);
-    expect(isAlive(proc.pid!)).toBe(false);
-
-    try {
-      unlinkSync(childScript);
-      if (existsSync(pidFile)) unlinkSync(pidFile);
-    } catch {
-      // 忽略清理失败
-    }
-  }, 30000);
-
-  it("does not throw when pid does not exist", async () => {
-    await expect(killProcessTree(999999)).resolves.toBeUndefined();
-  });
-
-  it("does not throw when pid is undefined", async () => {
-    await expect(killProcessTree(undefined)).resolves.toBeUndefined();
-  });
-});

package/src/__tests__/progress-reducer.test.ts

@@ -1,121 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import type { ChatEvent } from "../../deepccc-agent/src/index.ts";
-import { reduceProgress, summarizeToolInput, summarizeToolResult } from "../progress/reducer.ts";
-import { progressView } from "../progress/view.ts";
-
-function feed(events: ChatEvent[]) {
-  return events.reduce(reduceProgress, progressView({ headerTitle: "生成中..." }));
-}
-
-describe("reduceProgress", () => {
-  it("renders explicit compaction and generation phases", () => {
-    const compacting = reduceProgress(
-      progressView({ headerTitle: "Generating..." }),
-      { type: "status", phase: "compacting" },
-    );
-    expect(compacting.headerTitle).toBe("压缩上下文中...");
-
-    const generating = reduceProgress(compacting, { type: "status", phase: "generating" });
-    expect(generating.headerTitle).toBe("生成回复中...");
-  });
-
-  it("accumulates text via accumulated field", () => {
-    const view = feed([
-      { type: "text", text: "Hello", accumulated: "Hello" },
-      { type: "text", text: " world", accumulated: "Hello world" },
-    ]);
-    expect(view.text).toBe("Hello world");
-    expect(view.status).toBe("generating");
-    expect(view.showStop).toBe(true);
-  });
-
-  it("appends tool_use as running and resolves status on tool_result", () => {
-    const view = feed([
-      { type: "tool_use", id: "t1", name: "edit_file", input: { path: "a.ts" } },
-      { type: "tool_result", tool_use_id: "t1", name: "edit_file", content: "ok", is_error: false },
-    ]);
-    expect(view.tools).toHaveLength(1);
-    expect(view.tools[0]).toMatchObject({
-      id: "t1",
-      name: "edit_file",
-      status: "ok",
-      summary: "ok",
-    });
-  });
-
-  it("marks tool as error when is_error is true", () => {
-    const view = feed([
-      { type: "tool_use", id: "t2", name: "run_command", input: { command: "npm test" } },
-      { type: "tool_result", tool_use_id: "t2", name: "run_command", content: "boom", is_error: true },
-    ]);
-    expect(view.tools[0].status).toBe("error");
-    expect(view.tools[0].summary).toBe("boom");
-  });
-
-  it("falls back to last running tool when tool_use_id mismatches", () => {
-    const view = feed([
-      { type: "tool_use", id: undefined, name: "list_dir", input: {} },
-      { type: "tool_result", tool_use_id: "unknown-id", name: "list_dir", content: "ok", is_error: false },
-    ]);
-    expect(view.tools[0].status).toBe("ok");
-  });
-
-  it("keeps multiple tool calls independently", () => {
-    const view = feed([
-      { type: "tool_use", id: "a", name: "read_file", input: { path: "a" } },
-      { type: "tool_use", id: "b", name: "read_file", input: { path: "b" } },
-      { type: "tool_result", tool_use_id: "b", name: "read_file", content: "bb", is_error: false },
-    ]);
-    expect(view.tools[0].status).toBe("running");
-    expect(view.tools[1].status).toBe("ok");
-  });
-
-  it("marks done: status done, showStop false, text finalized", () => {
-    const view = feed([
-      { type: "text", text: "part", accumulated: "part" },
-      { type: "done", text: "final answer" },
-    ]);
-    expect(view.status).toBe("done");
-    expect(view.showStop).toBe(false);
-    expect(view.text).toBe("final answer");
-  });
-
-  it("marks error status and keeps text", () => {
-    const view = feed([
-      { type: "text", text: "x", accumulated: "x" },
-      { type: "error", message: "boom" },
-    ]);
-    expect(view.status).toBe("error");
-    expect(view.showStop).toBe(false);
-    expect(view.text).toBe("x");
-  });
-
-  it("ignores compact events without changing the view identity", () => {
-    const base = progressView({ headerTitle: "生成中..." });
-    const result = reduceProgress(base, { type: "compact", compactedMessages: 5 });
-    expect(result).toBe(base);
-  });
-
-  it("does not mutate the previous view (immutable updates)", () => {
-    const base = progressView({ headerTitle: "生成中..." });
-    const next = reduceProgress(base, { type: "text", text: "hi", accumulated: "hi" });
-    expect(base.text).toBe("");
-    expect(next.text).toBe("hi");
-    expect(next).not.toBe(base);
-  });
-});
-
-describe("summarizeToolInput / summarizeToolResult", () => {
-  it("flattens multiline input to one line", () => {
-    const s = summarizeToolInput({ path: "a\nb", big: "x".repeat(200) });
-    expect(s).not.toContain("\n");
-    expect(s.length).toBeLessThanOrEqual(121);
-    expect(s.endsWith("…")).toBe(true);
-  });
-
-  it("takes first line of result content", () => {
-    expect(summarizeToolResult("line1\nline2\n")).toBe("line1");
-    expect(summarizeToolResult({ ok: true })).toBe('{"ok":true}');
-  });
-});

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

@@ -1,106 +0,0 @@
-import { gunzipSync } from "node:zlib";
-import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { describe, expect, it } from "vitest";
-
-import {
-  createRawStreamLog,
-  sanitizeLogPathSegment,
-} from "../adapters/raw-stream-log.ts";
-
-describe("raw stream log", () => {
-  it("does nothing when disabled", async () => {
-    const root = await mkdtemp(join(tmpdir(), "chatccc-raw-log-"));
-    try {
-      const log = await createRawStreamLog({
-        enabled: false,
-        rootDir: root,
-        tool: "cursor",
-        sessionId: "sid",
-        label: "turn",
-        maxBytesPerTurn: 1024,
-        retentionDays: 7,
-      });
-      expect(log).toBeNull();
-    } finally {
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-
-  it("writes gzipped JSONL and can keep the file", async () => {
-    const root = await mkdtemp(join(tmpdir(), "chatccc-raw-log-"));
-    try {
-      const log = await createRawStreamLog({
-        enabled: true,
-        rootDir: root,
-        tool: "cursor",
-        sessionId: "sid/unsafe",
-        label: "turn:1",
-        maxBytesPerTurn: 1024,
-        retentionDays: 7,
-      });
-      expect(log).not.toBeNull();
-      log!.writeLine('{"type":"assistant","text":"hello"}');
-      await log!.close({ keep: true });
-
-      const raw = gunzipSync(await readFile(log!.filePath)).toString("utf-8");
-      expect(raw).toBe('{"type":"assistant","text":"hello"}\n');
-      expect(await stat(log!.filePath)).toBeTruthy();
-    } finally {
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-
-  it("writes a truncation marker once maxBytesPerTurn is exceeded", async () => {
-    const root = await mkdtemp(join(tmpdir(), "chatccc-raw-log-"));
-    try {
-      const log = await createRawStreamLog({
-        enabled: true,
-        rootDir: root,
-        tool: "cursor",
-        sessionId: "sid",
-        label: "turn",
-        maxBytesPerTurn: 12,
-        retentionDays: 7,
-      });
-      log!.writeLine('{"a":1}');
-      log!.writeLine('{"too":"large"}');
-      log!.writeLine('{"ignored":true}');
-      await log!.close({ keep: true });
-
-      const raw = gunzipSync(await readFile(log!.filePath)).toString("utf-8");
-      expect(raw).toContain('{"a":1}');
-      expect(raw).toContain("chatccc_raw_stream_log_truncated");
-      expect(raw).not.toContain("ignored");
-    } finally {
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-
-  it("removes the file when keep is false", async () => {
-    const root = await mkdtemp(join(tmpdir(), "chatccc-raw-log-"));
-    try {
-      const log = await createRawStreamLog({
-        enabled: true,
-        rootDir: root,
-        tool: "cursor",
-        sessionId: "sid",
-        label: "turn",
-        maxBytesPerTurn: 1024,
-        retentionDays: 7,
-      });
-      log!.writeLine('{"type":"result"}');
-      await log!.close({ keep: false });
-      await expect(stat(log!.filePath)).rejects.toThrow();
-    } finally {
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-
-  it("sanitizes path segments", () => {
-    expect(sanitizeLogPathSegment("../sid:1/2")).toBe("sid_1_2");
-    expect(sanitizeLogPathSegment("")).toBe("unknown");
-  });
-});

package/src/__tests__/response-stall.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  hasResponseStalled,
-  observeResponseProgress,
-} from "../response-stall.ts";
-
-describe("response stall detection", () => {
-  it("starts tracking while responding even when the total character count is zero", () => {
-    const observation = observeResponseProgress(undefined, true, 0, 1_000);
-
-    expect(observation).toEqual({
-      totalChars: 0,
-      unchangedSince: 1_000,
-    });
-  });
-
-  it("auto-ends only after the same character count has lasted three minutes", () => {
-    const first = observeResponseProgress(undefined, true, 12, 1_000);
-    const unchanged = observeResponseProgress(first, true, 12, 90_000);
-
-    expect(unchanged).toBe(first);
-    expect(hasResponseStalled(unchanged, 180_999, 180_000)).toBe(false);
-    expect(hasResponseStalled(unchanged, 181_000, 180_000)).toBe(true);
-  });
-
-  it("restarts the timer whenever the total character count changes", () => {
-    const first = observeResponseProgress(undefined, true, 12, 1_000);
-    const changed = observeResponseProgress(first, true, 13, 150_000);
-
-    expect(changed).toEqual({
-      totalChars: 13,
-      unchangedSince: 150_000,
-    });
-    expect(hasResponseStalled(changed, 181_000, 180_000)).toBe(false);
-  });
-
-  it("clears tracking outside responding and starts a fresh window after returning", () => {
-    const first = observeResponseProgress(undefined, true, 0, 1_000);
-    const cleared = observeResponseProgress(first, false, 0, 100_000);
-    const resumed = observeResponseProgress(cleared, true, 0, 200_000);
-
-    expect(cleared).toBeUndefined();
-    expect(resumed).toEqual({
-      totalChars: 0,
-      unchangedSince: 200_000,
-    });
-  });
-});