chatccc 0.2.204 → 0.2.206

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.204",
+  "version": "0.2.206",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",

package/src/__tests__/agent-activity.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  createAgentActivityTracker,
+  formatAgentActivityTitle,
+  updateAgentActivity,
+} from "../agent-activity.ts";
+
+describe("agent activity", () => {
+  it("starts with an explicit startup status", () => {
+    const tracker = createAgentActivityTracker(1_000);
+
+    expect(formatAgentActivityTitle(tracker.activity, 4_000)).toBe("正在启动 Agent · 3秒");
+  });
+
+  it("keeps the thinking timer stable across repeated thinking blocks", () => {
+    const tracker = createAgentActivityTracker(1_000);
+
+    expect(updateAgentActivity(tracker, { type: "thinking", thinking: "first" }, 2_000)).toBe(true);
+    expect(updateAgentActivity(tracker, { type: "thinking", thinking: "second" }, 5_000)).toBe(false);
+    expect(formatAgentActivityTitle(tracker.activity, 8_000)).toBe("思考中 · 6秒");
+  });
+
+  it("shows the active tool name and elapsed time", () => {
+    const tracker = createAgentActivityTracker(1_000);
+
+    updateAgentActivity(tracker, {
+      type: "tool_use",
+      id: "tool-1",
+      name: "Bash",
+      input: { command: "npm test" },
+    }, 3_000);
+
+    expect(formatAgentActivityTitle(tracker.activity, 38_000)).toBe("正在执行 Bash · 35秒");
+  });
+
+  it("tracks parallel tools and keeps the remaining tool after one result", () => {
+    const tracker = createAgentActivityTracker(1_000);
+
+    updateAgentActivity(tracker, { type: "tool_use", id: "read", name: "Read", input: {} }, 2_000);
+    updateAgentActivity(tracker, { type: "tool_use", id: "grep", name: "Grep", input: {} }, 3_000);
+    expect(formatAgentActivityTitle(tracker.activity, 4_000)).toBe("正在执行 Read 等 2 项 · 2秒");
+
+    updateAgentActivity(tracker, {
+      type: "tool_result",
+      tool_use_id: "read",
+      content: "done",
+    }, 5_000);
+    expect(formatAgentActivityTitle(tracker.activity, 7_000)).toBe("正在执行 Grep · 4秒");
+
+    updateAgentActivity(tracker, {
+      type: "tool_result",
+      tool_use_id: "grep",
+      content: "done",
+    }, 8_000);
+    expect(formatAgentActivityTitle(tracker.activity, 10_000)).toBe("正在处理工具结果 · 2秒");
+  });
+
+  it("switches to response and context-compaction statuses", () => {
+    const tracker = createAgentActivityTracker(1_000);
+
+    updateAgentActivity(tracker, { type: "text", text: "answer" }, 2_000);
+    expect(formatAgentActivityTitle(tracker.activity, 3_000)).toBe("正在生成回复 · 1秒");
+
+    updateAgentActivity(tracker, {
+      type: "compact_boundary",
+      trigger: "auto",
+      pre_tokens: 100_000,
+    }, 4_000);
+    expect(formatAgentActivityTitle(tracker.activity, 5_000)).toBe("正在整理上下文 · 1秒");
+  });
+
+  it("formats longer elapsed time without decorative animation", () => {
+    expect(formatAgentActivityTitle({ kind: "thinking", startedAt: 1_000 }, 74_000)).toBe("思考中 · 1分13秒");
+  });
+});

package/src/__tests__/codex-adapter.test.ts

@@ -76,12 +76,12 @@ describe("normalizeCodexMessage", () => {
         status: "in_progress",
       },
     });
-    expect(result).not.toBeNull();
-    expect(result!.type).toBe("assistant");
-    expect(result!.blocks).toEqual([
-      { type: "tool_use", name: "Bash", input: { command: "powershell.exe -Command ls" } },
-    ]);
-  });
+    expect(result).not.toBeNull();
+    expect(result!.type).toBe("assistant");
+    expect(result!.blocks).toEqual([
+      { type: "tool_use", id: "item_0", name: "Bash", input: { command: "powershell.exe -Command ls" } },
+    ]);
+  });
 
   it("normalizes command_execution completion as tool_result (success)", () => {
     const result = normalizeCodexMessage({
@@ -302,4 +302,4 @@ describe("createCodexAdapter", () => {
     });
     expect(await adapter.getSessionInfo("sid-C")).toBeUndefined();
   });
-});
+});

package/src/__tests__/cursor-adapter.test.ts

@@ -660,11 +660,11 @@ describe("Cursor stream fixture - 端到端不重复", () => {
       session_id: "sid",
       timestamp_ms: 1000,
     } as Parameters<typeof normalizeCursorMessage>[0]);
-    expect(result).not.toBeNull();
-    expect(result!.blocks).toEqual([
-      { type: "tool_use", name: "Bash", input: { command: "ls" } },
-    ]);
-  });
+    expect(result).not.toBeNull();
+    expect(result!.blocks).toEqual([
+      { type: "tool_use", id: "toolu_abc", name: "Bash", input: { command: "ls" } },
+    ]);
+  });
 
   it("normalizes tool_call completed → tool_result block (success)", () => {
     const result = normalizeCursorMessage({

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

@@ -0,0 +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,
+    });
+  });
+});

package/src/__tests__/session.test.ts

@@ -1,13 +1,25 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import { mkdtemp, rm, readFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-
-// mock stream-state 以支持在测试中控制累积长度
-const mockStreamStates = new Map<string, {
-  accumulatedContent: string;
-  finalReply: string;
-  status?: "running" | "done" | "stopped" | "error";
+import { dirname, join } from "node:path";
+
+const killProcessTreeMock = vi.hoisted(() => vi.fn(async () => {}));
+vi.mock("../adapters/proc-tree-kill.ts", () => ({
+  killProcessTree: killProcessTreeMock,
+}));
+
+// mock stream-state 以支持在测试中控制累积长度
+const mockStreamStates = new Map<string, {
+  accumulatedContent: string;
+  finalReply: string;
+  activity?: {
+    kind: "starting" | "thinking" | "tool" | "processing" | "responding" | "searching" | "compacting";
+    startedAt: number;
+    toolName?: string;
+    toolCount?: number;
+  };
+  status?: "running" | "done" | "stopped" | "error" | "auto_ended";
+  autoEndedAt?: number;
   turnCount?: number;
   finalReplySentTurn?: number;
   finalReplySentAt?: number;
@@ -18,10 +30,12 @@ vi.mock("../stream-state.ts", () => ({
     if (!state) return null;
     return {
       sessionId: sid,
-      accumulatedContent: state.accumulatedContent,
-      finalReply: state.finalReply,
-      finalReplySentTurn: state.finalReplySentTurn,
-      finalReplySentAt: state.finalReplySentAt,
+      accumulatedContent: state.accumulatedContent,
+      finalReply: state.finalReply,
+      activity: state.activity,
+      finalReplySentTurn: state.finalReplySentTurn,
+      finalReplySentAt: state.finalReplySentAt,
+      autoEndedAt: state.autoEndedAt,
       status: state.status ?? "running",
       chunkCount: 0,
       turnCount: state.turnCount ?? 0,
@@ -34,24 +48,33 @@ vi.mock("../stream-state.ts", () => ({
   writeStreamState: async (state: {
     sessionId: string;
     accumulatedContent: string;
-    finalReply: string;
-    status?: "running" | "done" | "stopped" | "error";
+    finalReply: string;
+    activity?: {
+      kind: "starting" | "thinking" | "tool" | "processing" | "responding" | "searching" | "compacting";
+      startedAt: number;
+      toolName?: string;
+      toolCount?: number;
+    };
+    status?: "running" | "done" | "stopped" | "error" | "auto_ended";
+    autoEndedAt?: number;
     turnCount?: number;
     finalReplySentTurn?: number;
     finalReplySentAt?: number;
   }) => {
     mockStreamStates.set(state.sessionId, {
-      accumulatedContent: state.accumulatedContent,
-      finalReply: state.finalReply,
-      status: state.status,
+      accumulatedContent: state.accumulatedContent,
+      finalReply: state.finalReply,
+      activity: state.activity,
+      status: state.status,
+      autoEndedAt: state.autoEndedAt,
       turnCount: state.turnCount,
       finalReplySentTurn: state.finalReplySentTurn,
       finalReplySentAt: state.finalReplySentAt,
     });
   },
-  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,
-  }),
+  createEmptyStreamState: (sid: string, cwd: string, tool: string, turnCount: number) => ({
+    sessionId: sid, status: "running" as const, accumulatedContent: "", finalReply: "", activity: { kind: "starting" as const, startedAt: Date.now() }, chunkCount: 0, turnCount, contextTokens: 0, updatedAt: Date.now(), cwd, tool,
+  }),
   isFinalReplySentForTurn: (state: { turnCount: number; finalReplySentTurn?: number }) => state.finalReplySentTurn === state.turnCount,
   markFinalReplySent: async (sid: string, turnCount: number, sentAt = Date.now()) => {
     const state = mockStreamStates.get(sid);
@@ -95,6 +118,10 @@ import {
   _resetProcessAliveForTest,
   _setProcessMonitorIntervalForTest,
   _resetProcessMonitorIntervalForTest,
+  _setResponseStallTimeoutForTest,
+  _resetResponseStallTimeoutForTest,
+  _setResponseStallCheckIntervalForTest,
+  _resetResponseStallCheckIntervalForTest,
   setSessionEffortOverride,
 } from "../session.ts";
 import {
@@ -335,13 +362,15 @@ describe("runAgentSession process monitor", () => {
     _resetSessionRegistryFileForTest();
     _resetSessionToolsFileForTest();
     _clearAdapterCacheForTest();
-    _resetProcessAliveForTest();
-    _resetProcessMonitorIntervalForTest();
+    _resetProcessAliveForTest();
+    _resetProcessMonitorIntervalForTest();
+    _resetResponseStallTimeoutForTest();
+    _resetResponseStallCheckIntervalForTest();
     resetBindingState();
     vi.useRealTimers();
   });
 
-  it("marks the turn as error and sends a separate notice when the CLI process disappears", async () => {
+  it("marks the turn as error and sends a separate notice when the CLI process disappears", async () => {
     const platform = mockPlatform("feishu");
     setSessionPlatform(platform);
     bindChatToSession("sid-process", "chat-process");
@@ -569,8 +598,108 @@ describe("runAgentSession process monitor", () => {
   });
 });
 
-describe("unified display loop WeChat delta", () => {
-  beforeEach(() => {
+describe("runAgentSession response stall watchdog", () => {
+  let tempDir = "";
+
+  beforeEach(async () => {
+    vi.useFakeTimers();
+    resetState();
+    resetBindingState();
+    mockStreamStates.clear();
+    killProcessTreeMock.mockClear();
+    tempDir = await mkdtemp(join(tmpdir(), "chatccc-response-stall-"));
+    _setSessionRegistryFileForTest(join(tempDir, "session-registry.json"));
+    _setSessionToolsFileForTest(join(tempDir, "session-tools.json"));
+  });
+
+  afterEach(async () => {
+    _resetSessionRegistryFileForTest();
+    _resetSessionToolsFileForTest();
+    _clearAdapterCacheForTest();
+    _resetProcessAliveForTest();
+    _resetResponseStallTimeoutForTest();
+    _resetResponseStallCheckIntervalForTest();
+    resetBindingState();
+    vi.useRealTimers();
+    if (tempDir) await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it("auto-ends every Agent after three minutes of unchanged reply characters, including zero", async () => {
+    vi.setSystemTime(0);
+    _setResponseStallTimeoutForTest(180_000);
+    _setResponseStallCheckIntervalForTest(1_000);
+    _setProcessAliveForTest(() => true);
+
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+    bindChatToSession("sid-response-stall", "chat-response-stall");
+    recordLastActiveChat("sid-response-stall", "chat-response-stall");
+
+    const closeSession = vi.fn();
+    const adapter: ToolAdapter = {
+      displayName: "Any Agent",
+      sessionDescPrefix: "Agent Session:",
+      createSession: async () => ({ sessionId: "sid-response-stall" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
+      closeSession: async () => {},
+      prompt: async function* (
+        _sid: string,
+        _text: string,
+        _cwd: string,
+        signal?: AbortSignal,
+        options?: ToolPromptOptions,
+      ) {
+        options?.onSessionCreated?.(closeSession);
+        options?.onProcessStart?.({ pid: 4242 });
+        yield { type: "assistant", blocks: [{ type: "text", text: "" }] };
+        await new Promise<void>((resolve) => {
+          if (signal?.aborted) {
+            resolve();
+            return;
+          }
+          signal?.addEventListener("abort", () => resolve(), { once: true });
+        });
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
+
+    const runPromise = runAgentSession(
+      "sid-response-stall",
+      "prompt",
+      platform,
+      "chat-response-stall",
+      Date.now(),
+      "claude",
+    );
+
+    await vi.waitFor(() => {
+      expect(activePrompts.get("sid-response-stall")?.responseProgress).toEqual({
+        totalChars: 0,
+        unchangedSince: expect.any(Number),
+      });
+    });
+
+    const progress = activePrompts.get("sid-response-stall")!.responseProgress!;
+    const remainingBeforeBoundary = progress.unchangedSince + 180_000 - Date.now() - 1;
+    await vi.advanceTimersByTimeAsync(remainingBeforeBoundary);
+    expect(activePrompts.has("sid-response-stall")).toBe(true);
+
+    await vi.advanceTimersByTimeAsync(1_001);
+    await runPromise;
+
+    expect(closeSession).toHaveBeenCalledTimes(1);
+    expect(killProcessTreeMock).toHaveBeenCalledWith(4242);
+    expect(activePrompts.has("sid-response-stall")).toBe(false);
+    expect(mockStreamStates.get("sid-response-stall")).toMatchObject({
+      status: "auto_ended",
+      finalReply: "",
+      autoEndedAt: expect.any(Number),
+    });
+  });
+});
+
+describe("unified display loop WeChat delta", () => {
+  beforeEach(() => {
     vi.useFakeTimers();
     resetState();
     resetBindingState();
@@ -636,10 +765,77 @@ describe("unified display loop WeChat delta", () => {
       "chat-wechat",
       "tool output",
     );
-  });
-});
-
-describe("unified display loop terminal card update", () => {
+  });
+
+});
+
+describe("unified display loop activity status", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-07-16T08:00:00.000Z"));
+    resetState();
+    resetBindingState();
+    mockStreamStates.clear();
+  });
+
+  afterEach(() => {
+    stopUnifiedDisplayLoop();
+    resetBindingState();
+    vi.useRealTimers();
+  });
+
+  it("renders explicit activity and elapsed time alongside the liveness dots", async () => {
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+
+    bindChatToSession("sid-activity", "chat-activity");
+    recordLastActiveChat("sid-activity", "chat-activity");
+    sessionInfoMap.set("chat-activity", {
+      sessionId: "sid-activity",
+      turnCount: 1,
+      lastContextTokens: 0,
+      startTime: Date.now() - 12_000,
+      tool: "codex",
+    });
+    displayCards.set("chat-activity", {
+      cardId: "card-activity",
+      sequence: 1,
+      cardBusy: false,
+      cardCreatedAt: Date.now(),
+      lastSentContent: "",
+      streamErrorNotified: false,
+      sessionId: "sid-activity",
+      turnCount: 1,
+      dotCount: 0,
+    });
+    mockStreamStates.set("sid-activity", {
+      accumulatedContent: "正在检查日志",
+      finalReply: "",
+      activity: {
+        kind: "tool",
+        startedAt: Date.now() - 12_000,
+        toolName: "Shell",
+        toolCount: 1,
+      },
+      status: "running",
+      turnCount: 1,
+    });
+
+    startUnifiedDisplayLoop();
+    await vi.advanceTimersByTimeAsync(3_000);
+
+    const payload = vi.mocked(platform.cardUpdate).mock.calls[0]?.[1];
+    expect(payload).toBeTypeOf("string");
+    const card = JSON.parse(payload as string) as {
+      header: { title: { content: string } };
+      body: { elements: Array<{ tag: string; content?: string }> };
+    };
+    expect(card.header.title.content).toBe("正在执行 Shell · 15秒");
+    expect(card.body.elements[0]?.content).toBe("正在检查日志\n。");
+  });
+});
+
+describe("unified display loop terminal card update", () => {
   beforeEach(() => {
     vi.useFakeTimers();
     resetState();
@@ -647,13 +843,61 @@ describe("unified display loop terminal card update", () => {
     mockStreamStates.clear();
   });
 
-  afterEach(() => {
+  afterEach(() => {
     stopUnifiedDisplayLoop();
     resetBindingState();
-    vi.useRealTimers();
-  });
-
-  it("does not repeat the same terminal CardKit sequence while the prompt is still active", async () => {
+    vi.useRealTimers();
+  });
+
+  it("shows a distinct auto-ended state and sends a warning even with an empty reply", async () => {
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+
+    bindChatToSession("sid-auto-ended", "chat-auto-ended");
+    recordLastActiveChat("sid-auto-ended", "chat-auto-ended");
+    sessionInfoMap.set("chat-auto-ended", {
+      sessionId: "sid-auto-ended",
+      turnCount: 1,
+      lastContextTokens: 0,
+      startTime: 0,
+      tool: "cursor",
+    });
+    displayCards.set("chat-auto-ended", {
+      cardId: "card-auto-ended",
+      sequence: 1,
+      cardBusy: false,
+      cardCreatedAt: Date.now(),
+      lastSentContent: "",
+      streamErrorNotified: false,
+      sessionId: "sid-auto-ended",
+      turnCount: 1,
+      dotCount: 0,
+    });
+    mockStreamStates.set("sid-auto-ended", {
+      accumulatedContent: "",
+      finalReply: "",
+      status: "auto_ended",
+      turnCount: 1,
+      autoEndedAt: 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 };
+    };
+    expect(card.header.title.content).toBe("已自动结束 · 3分钟无新内容");
+    expect(card.header.template).toBe("orange");
+    expect(platform.sendText).toHaveBeenCalledWith(
+      "chat-auto-ended",
+      "⚠️ 已自动结束：连续 3 分钟处于“正在生成回复”且回复字符总数没有变化。本轮没有可发送的回复内容。",
+    );
+    expect(displayCards.has("chat-auto-ended")).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 () => {
       throw new Error("CardKit update: [300317] ErrMsg: sequence number compare failed; ");

package/src/adapters/codex-adapter.ts

@@ -153,6 +153,7 @@ export function normalizeCodexMessage(
       blocks: [
         {
           type: "tool_use",
+          id: msg.item.id,
           name: "Bash",
           input: { command: msg.item.command },
         },

package/src/adapters/cursor-adapter.ts

@@ -297,6 +297,7 @@ export function normalizeCursorMessage(
         blocks: [
           {
             type: "tool_use",
+            id: msg.call_id,
             name: mapToolCallKey(toolKey),
             input: toolData.args ?? {},
           },