chatccc 0.2.231 → 0.2.233

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

@@ -1,106 +1,106 @@
-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");
-  });
-});
+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 +1,49 @@
-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,
-    });
-  });
-});
+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,
+    });
+  });
+});

package/src/__tests__/restart.test.ts

@@ -1,7 +1,9 @@
 import { EventEmitter } from "node:events";
+import { mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { describe, expect, it, vi } from "vitest";
+import { describe, expect, it, vi, afterEach } from "vitest";
 
 import {
   buildRestartSpawnSpec,
@@ -36,12 +38,25 @@ describe("spawnRestartChild", () => {
     stderr = new EventEmitter();
   }
 
-  it("spawns without a shell, captures stderr, and marks the internal restart env", () => {
+  let tmpDirs: string[] = [];
+  afterEach(async () => {
+    for (const dir of tmpDirs) await rm(dir, { recursive: true, force: true });
+    tmpDirs = [];
+  });
+
+  async function tmpLogDir(): Promise<string> {
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-restart-"));
+    tmpDirs.push(dir);
+    return dir;
+  }
+
+  it("spawns without a shell, redirects stderr to a restart log file, and marks the internal restart env", async () => {
+    const logDir = await tmpLogDir();
     const fake = new FakeChild();
     const spawnImpl = vi.fn(() => fake as never);
     const trace = vi.fn();
 
-    const child = spawnRestartChild({ projectRoot: "F:/proj", spawnImpl, trace });
+    const child = spawnRestartChild({ projectRoot: "F:/proj", spawnImpl, trace, restartLogDir: logDir });
 
     expect(child).toBe(fake);
     expect(spawnImpl).toHaveBeenCalledWith(
@@ -49,7 +64,6 @@ describe("spawnRestartChild", () => {
       [join("F:/proj", "node_modules", "tsx", "dist", "cli.mjs"), "src/index.ts"],
       expect.objectContaining({
         detached: true,
-        stdio: ["ignore", "ignore", "pipe"],
         env: expect.objectContaining({ [INTERNAL_RESTART_ENV_VAR]: "1" }),
         // 不使用 shell：避免 npm/npx 的 PATH 注入问题
         shell: false,
@@ -59,17 +73,28 @@ describe("spawnRestartChild", () => {
     const firstCall = spawnImpl.mock.calls[0] as unknown as [string, string[]];
     const [cmd, args] = firstCall;
     expect([cmd, ...args].join(" ")).not.toMatch(/npx|npm/i);
+
+    // stderr 指向磁盘日志文件（fd），而不是 pipe：pipe 读端随父进程退出关闭后，
+    // 子进程写 stderr 会 EPIPE 崩溃（飞书 SDK console.warn 崩溃根因）。
+    const callArgs = spawnImpl.mock.calls[0] as unknown as Array<unknown>;
+    const stdio = (callArgs[2] as { stdio: unknown[] }).stdio;
+    expect(stdio[0]).toBe("ignore");
+    expect(stdio[1]).toBe("ignore");
+    expect(typeof stdio[2]).toBe("number");
+    expect(stdio[2] as number).toBeGreaterThan(2);
+
+    const files = await readdir(logDir);
+    expect(files.some((f) => f.startsWith("restart-") && f.endsWith(".log"))).toBe(true);
   });
 
-  it("writes captured stderr into the trace on child exit", () => {
+  it("records child exit code/signal in trace without pipe capture", async () => {
+    const logDir = await tmpLogDir();
     const fake = new FakeChild();
     const spawnImpl = vi.fn(() => fake as never);
     const trace = vi.fn();
 
-    spawnRestartChild({ projectRoot: "F:/proj", spawnImpl, trace });
+    spawnRestartChild({ projectRoot: "F:/proj", spawnImpl, trace, restartLogDir: logDir });
 
-    fake.stderr.emit("data", Buffer.from("tsx error line 1\n"));
-    fake.stderr.emit("data", Buffer.from("tsx error line 2\n"));
     fake.exitCode = 1;
     fake.emit("exit", 1, null);
 
@@ -80,8 +105,28 @@ describe("spawnRestartChild", () => {
       code: 1,
       signal: null,
     }));
-    expect(exitCall![1].stderr).toContain("tsx error line 1");
-    expect(exitCall![1].stderr).toContain("tsx error line 2");
+    // 不再用 pipe 收集 stderr，trace 里不再有 stderr 字段
+    expect(exitCall![1]).not.toHaveProperty("stderr");
+  });
+
+  it("falls back to pipe capture when the stderr log file cannot be opened", async () => {
+    const dir = await tmpLogDir();
+    // 用普通文件顶替目录：mkdir/open 日志文件必然失败
+    const blocker = join(dir, "blocker");
+    await writeFile(blocker, "x");
+    const fake = new FakeChild();
+    const spawnImpl = vi.fn(() => fake as never);
+    const trace = vi.fn();
+
+    spawnRestartChild({ projectRoot: "F:/proj", spawnImpl, trace, restartLogDir: blocker });
+
+    const callArgs = spawnImpl.mock.calls[0] as unknown as Array<unknown>;
+    expect((callArgs[2] as { stdio: unknown[] }).stdio[2]).toBe("pipe");
+    const failCall = trace.mock.calls.find(
+      ([name]) => name === "restart: stderr log open failed, falling back to pipe",
+    );
+    expect(failCall).toBeTruthy();
+    expect(typeof (failCall![1] as { error: unknown }).error).toBe("string");
   });
 });