chatccc 0.2.229 → 0.2.231

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__/session.test.ts

@@ -23,6 +23,12 @@ const mockStreamStates = new Map<string, {
   turnCount?: number;
   finalReplySentTurn?: number;
   finalReplySentAt?: number;
+  terminalError?: {
+    kind: "network_timeout" | "network" | "authentication" | "rate_limit" | "provider" | "process" | "resource" | "unknown";
+    title: string;
+    message: string;
+    occurredAt: number;
+  };
 }>();
 vi.mock("../stream-state.ts", () => ({
   readStreamState: async (sid: string) => {
@@ -35,6 +41,7 @@ vi.mock("../stream-state.ts", () => ({
       activity: state.activity,
       finalReplySentTurn: state.finalReplySentTurn,
       finalReplySentAt: state.finalReplySentAt,
+      terminalError: state.terminalError,
       autoEndedAt: state.autoEndedAt,
       status: state.status ?? "running",
       chunkCount: 0,
@@ -60,6 +67,12 @@ vi.mock("../stream-state.ts", () => ({
     turnCount?: number;
     finalReplySentTurn?: number;
     finalReplySentAt?: number;
+    terminalError?: {
+      kind: "network_timeout" | "network" | "authentication" | "rate_limit" | "provider" | "process" | "resource" | "unknown";
+      title: string;
+      message: string;
+      occurredAt: number;
+    };
   }) => {
     mockStreamStates.set(state.sessionId, {
       accumulatedContent: state.accumulatedContent,
@@ -70,6 +83,7 @@ vi.mock("../stream-state.ts", () => ({
       turnCount: state.turnCount,
       finalReplySentTurn: state.finalReplySentTurn,
       finalReplySentAt: state.finalReplySentAt,
+      terminalError: state.terminalError,
     });
   },
   createEmptyStreamState: (sid: string, cwd: string, tool: string, turnCount: number) => ({
@@ -510,6 +524,51 @@ describe("runAgentSession process monitor", () => {
     );
   });
 
+  it("persists and sends the root cause when the agent stream fails before producing output", async () => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const platform = mockPlatform("feishu");
+    platform.cardCreate = vi.fn(async () => {
+      throw new Error("CardKit unavailable");
+    });
+    setSessionPlatform(platform);
+    bindChatToSession("sid-stream-error", "chat-stream-error");
+    recordLastActiveChat("sid-stream-error", "chat-stream-error");
+
+    const adapter: ToolAdapter = {
+      displayName: "CCC Agent",
+      sessionDescPrefix: "CCC Session:",
+      createSession: async () => ({ sessionId: "sid-stream-error" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "/tmp" }),
+      closeSession: async () => {},
+      prompt: async function* () {
+        throw new Error(
+          "Failed after 3 attempts. Last error: Cannot connect to API: " +
+          "Connect Timeout Error (timeout: 10000ms)",
+        );
+      },
+    };
+    _setAdapterForToolForTest("ccc", adapter);
+
+    const outcome = await runAgentSession(
+      "sid-stream-error",
+      "prompt",
+      platform,
+      "chat-stream-error",
+      Date.now(),
+      "ccc",
+    );
+
+    const state = mockStreamStates.get("sid-stream-error");
+    expect(outcome).toBe("error");
+    expect(state?.status).toBe("error");
+    expect(state?.terminalError?.kind).toBe("network_timeout");
+    expect(state?.terminalError?.message).toContain("已重试 3 次");
+    expect(platform.sendText).toHaveBeenCalledWith(
+      "chat-stream-error",
+      expect.stringContaining("网络连接超时"),
+    );
+  });
+
   it("recreates the progress card when the initial CardKit send fails", async () => {
     vi.spyOn(console, "error").mockImplementation(() => {});
     const platform = mockPlatform("feishu");
@@ -848,7 +907,7 @@ describe("runAgentSession response stall watchdog", () => {
     });
   });
 
-  it("auto-ends an Agent that stays in starting state without emitting any event", async () => {
+  it("does not apply the reply-stall timeout while an Agent is compacting context", async () => {
     vi.setSystemTime(0);
     _setResponseStallTimeoutForTest(180_000);
     _setResponseStallCheckIntervalForTest(1_000);
@@ -875,6 +934,7 @@ describe("runAgentSession response stall watchdog", () => {
       ) {
         options?.onSessionCreated?.(closeSession);
         options?.onProcessStart?.({ pid: 4343 });
+        yield { type: "assistant", blocks: [{ type: "agent_status", status: "compacting" }] };
         await new Promise<void>((resolve) => {
           if (signal?.aborted) {
             resolve();
@@ -899,11 +959,8 @@ describe("runAgentSession response stall watchdog", () => {
     await vi.waitFor(() => {
       expect(activePrompts.get("sid-starting-stall")).toMatchObject({
         processPid: 4343,
-        responseProgress: {
-          totalChars: 0,
-          unchangedSince: expect.any(Number),
-        },
       });
+      expect(activePrompts.get("sid-starting-stall")?.responseProgress).toBeUndefined();
       expect(closeSession).toHaveBeenCalledTimes(0);
     });
 
@@ -915,19 +972,16 @@ describe("runAgentSession response stall watchdog", () => {
       .length;
 
     // 旧实现不会结束真正的零事件启动；先清理测试会话，避免失败用例悬挂。
-    if (stateAfterDeadline?.status !== "auto_ended") {
-      stopSession("sid-starting-stall");
-      await vi.advanceTimersByTimeAsync(1_000);
-    }
+    stopSession("sid-starting-stall");
+    await vi.advanceTimersByTimeAsync(1_000);
     await runPromise;
 
     expect(stateAfterDeadline).toMatchObject({
-      status: "auto_ended",
-      finalReply: "",
-      autoEndedAt: expect.any(Number),
+      status: "running",
+      activity: { kind: "compacting" },
     });
-    expect(closeCountAfterDeadline).toBe(1);
-    expect(treeKillCountAfterDeadline).toBeGreaterThanOrEqual(1);
+    expect(closeCountAfterDeadline).toBe(0);
+    expect(treeKillCountAfterDeadline).toBe(0);
   });
 
   it("self-heals a missing trigger-chat binding and gives automatic recovery the normal card lifecycle", async () => {
@@ -1371,7 +1425,7 @@ describe("runAgentSession response stall watchdog", () => {
     expect(receivedPrompts[1]).toContain(recoveryPrompt);
     expect(platform.sendText).toHaveBeenCalledWith(
       "chat-recovery-limit",
-      "⚠️ 自动续跑仍连续 3 分钟没有启动进展或新回复，本次不再自动继续。",
+      "⚠️ 自动续跑仍连续 3 分钟没有生成新回复，本次不再自动继续。",
     );
   });
 
@@ -1630,11 +1684,115 @@ describe("unified display loop terminal card update", () => {
     expect(card.header.template).toBe("orange");
     expect(platform.sendText).toHaveBeenCalledWith(
       "chat-auto-ended",
-      "⚠️ 已自动结束：连续 3 分钟没有启动进展或回复字符变化。本轮没有可发送的回复内容。",
+      "⚠️ 已自动结束：生成回复阶段连续 3 分钟没有字符变化。本轮没有可发送的回复内容。",
     );
     expect(displayCards.has("chat-auto-ended")).toBe(false);
   });
 
+  it("shows the stream root cause in the error card without a duplicate text notice", async () => {
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+
+    bindChatToSession("sid-network-error", "chat-network-error");
+    recordLastActiveChat("sid-network-error", "chat-network-error");
+    sessionInfoMap.set("chat-network-error", {
+      sessionId: "sid-network-error",
+      turnCount: 1,
+      lastContextTokens: 0,
+      startTime: 0,
+      tool: "ccc",
+    });
+    displayCards.set("chat-network-error", {
+      cardId: "card-network-error",
+      sequence: 1,
+      cardBusy: false,
+      cardCreatedAt: Date.now(),
+      lastSentContent: "",
+      streamErrorNotified: false,
+      sessionId: "sid-network-error",
+      turnCount: 1,
+      dotCount: 0,
+    });
+    mockStreamStates.set("sid-network-error", {
+      accumulatedContent: "",
+      finalReply: "",
+      status: "error",
+      turnCount: 1,
+      terminalError: {
+        kind: "network_timeout",
+        title: "网络连接超时",
+        message: "连接模型服务失败，已重试 3 次，单次连接等待 10 秒。请检查网络、VPN或模型服务状态后重试。",
+        occurredAt: Date.now(),
+      },
+    });
+
+    startUnifiedDisplayLoop();
+    await vi.advanceTimersByTimeAsync(3_000);
+
+    const payload = vi.mocked(platform.cardUpdate).mock.calls[0]?.[1];
+    const card = JSON.parse(payload as string) as {
+      header: { title: { content: string }; template?: string };
+      body: { elements: Array<{ content?: string }> };
+    };
+    expect(card.header.title.content).toBe("异常结束 · 网络连接超时");
+    expect(card.header.template).toBe("red");
+    expect(card.body.elements[0]?.content).toContain("已重试 3 次");
+    expect(platform.sendText).not.toHaveBeenCalled();
+    expect(mockStreamStates.get("sid-network-error")?.finalReplySentTurn).toBe(1);
+    expect(displayCards.has("chat-network-error")).toBe(false);
+  });
+
+  it("falls back to a root-cause text when the error card cannot be updated", async () => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const platform = mockPlatform("feishu");
+    platform.cardUpdate = vi.fn(async () => {
+      throw new Error("CardKit unavailable");
+    });
+    setSessionPlatform(platform);
+
+    bindChatToSession("sid-error-fallback", "chat-error-fallback");
+    recordLastActiveChat("sid-error-fallback", "chat-error-fallback");
+    sessionInfoMap.set("chat-error-fallback", {
+      sessionId: "sid-error-fallback",
+      turnCount: 1,
+      lastContextTokens: 0,
+      startTime: 0,
+      tool: "ccc",
+    });
+    displayCards.set("chat-error-fallback", {
+      cardId: "card-error-fallback",
+      sequence: 1,
+      cardBusy: false,
+      cardCreatedAt: Date.now(),
+      lastSentContent: "",
+      streamErrorNotified: false,
+      sessionId: "sid-error-fallback",
+      turnCount: 1,
+      dotCount: 0,
+    });
+    mockStreamStates.set("sid-error-fallback", {
+      accumulatedContent: "",
+      finalReply: "",
+      status: "error",
+      turnCount: 1,
+      terminalError: {
+        kind: "network_timeout",
+        title: "网络连接超时",
+        message: "连接模型服务失败，已重试 3 次。",
+        occurredAt: Date.now(),
+      },
+    });
+
+    startUnifiedDisplayLoop();
+    await vi.advanceTimersByTimeAsync(3_000);
+
+    expect(platform.sendText).toHaveBeenCalledWith(
+      "chat-error-fallback",
+      expect.stringContaining("异常结束：网络连接超时"),
+    );
+    expect(displayCards.has("chat-error-fallback")).toBe(false);
+  });
+
   it("does not repeat the same terminal CardKit sequence while the prompt is still active", async () => {
     const platform = mockPlatform("feishu");
     platform.cardUpdate = vi.fn(async () => {

package/src/__tests__/shared-prefix.test.ts

@@ -1,36 +1,36 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  ABD_APPEND_PROMPT,
-  applySharedPrefix,
-} from "../shared-prefix.ts";
-
-describe("applySharedPrefix", () => {
-  it("leaves normal messages unchanged", () => {
-    expect(applySharedPrefix("帮我分析")).toEqual({
-      matched: false,
-      text: "帮我分析",
-      body: "帮我分析",
-    });
-  });
-
-  it("removes /abd without requiring a space", () => {
-    const result = applySharedPrefix("/abd帮我分析");
-
-    expect(result.matched).toBe(true);
-    expect(result.body).toBe("帮我分析");
-    expect(result.text).toBe(`帮我分析\n\n---\n${ABD_APPEND_PROMPT}`);
-  });
-
-  it("removes whitespace after /abd", () => {
-    const result = applySharedPrefix("/abd   帮我分析");
-
-    expect(result.text).toBe(`帮我分析\n\n---\n${ABD_APPEND_PROMPT}`);
-  });
-
-  it("keeps the appendix when the user body is empty", () => {
-    const result = applySharedPrefix("/abd   ");
-
-    expect(result.text).toBe(`---\n${ABD_APPEND_PROMPT}`);
-  });
-});
+import { describe, expect, it } from "vitest";
+
+import {
+  ABD_APPEND_PROMPT,
+  applySharedPrefix,
+} from "../shared-prefix.ts";
+
+describe("applySharedPrefix", () => {
+  it("leaves normal messages unchanged", () => {
+    expect(applySharedPrefix("帮我分析")).toEqual({
+      matched: false,
+      text: "帮我分析",
+      body: "帮我分析",
+    });
+  });
+
+  it("removes /abd without requiring a space", () => {
+    const result = applySharedPrefix("/abd帮我分析");
+
+    expect(result.matched).toBe(true);
+    expect(result.body).toBe("帮我分析");
+    expect(result.text).toBe(`帮我分析\n\n---\n${ABD_APPEND_PROMPT}`);
+  });
+
+  it("removes whitespace after /abd", () => {
+    const result = applySharedPrefix("/abd   帮我分析");
+
+    expect(result.text).toBe(`帮我分析\n\n---\n${ABD_APPEND_PROMPT}`);
+  });
+
+  it("keeps the appendix when the user body is empty", () => {
+    const result = applySharedPrefix("/abd   ");
+
+    expect(result.text).toBe(`---\n${ABD_APPEND_PROMPT}`);
+  });
+});