chatccc 0.2.170 → 0.2.172

package/package.json

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

package/src/__tests__/feishu-api.test.ts

@@ -0,0 +1,60 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { sendTextReply } from "../feishu-api.ts";
+
+function abortError(): Error {
+  const err = new Error("aborted");
+  err.name = "AbortError";
+  return err;
+}
+
+describe("sendTextReply timeout", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+  });
+
+  it("aborts a hung text send request", async () => {
+    vi.useFakeTimers();
+    vi.spyOn(console, "error").mockImplementation(() => {});
+
+    const fetchMock = vi.fn((_url: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => (
+      new Promise<Response>((_resolve, reject) => {
+        init?.signal?.addEventListener("abort", () => reject(abortError()));
+      })
+    ));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const send = expect(sendTextReply("token", "chat-1", "hello"))
+      .resolves.toBe(false);
+    await vi.advanceTimersByTimeAsync(15_000);
+
+    await send;
+    expect(fetchMock).toHaveBeenCalledWith(
+      expect.stringContaining("/im/v1/messages?receive_id_type=chat_id"),
+      expect.objectContaining({ signal: expect.any(AbortSignal) }),
+    );
+  });
+
+  it("also aborts when response body reading hangs", async () => {
+    vi.useFakeTimers();
+    vi.spyOn(console, "error").mockImplementation(() => {});
+
+    const fetchMock = vi.fn((_url: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => (
+      Promise.resolve({
+        status: 200,
+        text: () => new Promise<string>((_resolve, reject) => {
+          init?.signal?.addEventListener("abort", () => reject(abortError()));
+        }),
+      } as Response)
+    ));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const send = expect(sendTextReply("token", "chat-2", "hello"))
+      .resolves.toBe(false);
+    await vi.advanceTimersByTimeAsync(15_000);
+
+    await send;
+  });
+});

package/src/__tests__/orchestrator.test.ts

@@ -169,6 +169,26 @@ describe("handleCommand WeChat processing ack", () => {
     expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
   });
 
+  it("does not send the stopped success text until the running prompt really exits", async () => {
+    const platform = mockPlatform();
+    await recordSessionRegistry({
+      chatId: "wx-chat",
+      sessionId: "sid-wechat",
+      tool: "claude",
+      chatName: "busy-session",
+      running: true,
+    });
+    activePrompts.set("sid-wechat", {
+      controller: new AbortController(),
+      stopped: false,
+      startTime: Date.now(),
+    });
+
+    await handleCommand(platform, "/stop", "wx-chat", "wx-user", Date.now(), "p2p");
+
+    expect(platform.sendText).not.toHaveBeenCalledWith("wx-chat", "会话已停止。");
+  });
+
   it("cleans stale Feishu p2p binding, creates a group, and sends the private message as first prompt", async () => {
     const platform = mockPlatform("feishu");
     const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
@@ -177,7 +197,7 @@ describe("handleCommand WeChat processing ack", () => {
         blocks: [{ type: "text" as const, text: `收到: ${userText}` }],
       };
     });
-    _setAdapterForToolForTest("claude", {
+    _setAdapterForToolForTest("claude", {
       displayName: "Claude",
       sessionDescPrefix: "Claude Session:",
       createSession: vi.fn(async () => ({ sessionId: "sid-feishu-new" })),

package/src/__tests__/session.test.ts

@@ -88,6 +88,7 @@ import {
   recordChatPlatform,
   _getPlatformForChatForTest,
   runAgentSession,
+  stopSession,
   startUnifiedDisplayLoop,
   stopUnifiedDisplayLoop,
   _setProcessAliveForTest,
@@ -396,6 +397,66 @@ describe("runAgentSession process monitor", () => {
       expect.stringContaining("进程异常结束"),
     );
   });
+
+  it("sends the stopped notice only after the prompt generator exits", async () => {
+    const platform = mockPlatform("feishu");
+    setSessionPlatform(platform);
+    bindChatToSession("sid-stop-notice", "chat-stop-notice");
+    recordLastActiveChat("sid-stop-notice", "chat-stop-notice");
+
+    const closeSession = vi.fn();
+    let releasePrompt: (() => void) | undefined;
+    const adapter: ToolAdapter = {
+      displayName: "Claude Code",
+      sessionDescPrefix: "Claude Code Session:",
+      createSession: async () => ({ sessionId: "sid-stop-notice" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
+      closeSession: async () => {},
+      prompt: async function* (
+        _sid: string,
+        _text: string,
+        _cwd: string,
+        signal?: AbortSignal,
+        options?: ToolPromptOptions,
+      ) {
+        const waitForStop = new Promise<void>((resolve) => {
+          releasePrompt = resolve;
+          signal?.addEventListener("abort", () => resolve(), { once: true });
+        });
+        options?.onSessionCreated?.(() => {
+          closeSession();
+          releasePrompt?.();
+        });
+        yield { type: "assistant", blocks: [{ type: "text", text: "partial answer" }] };
+        await waitForStop;
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
+
+    const runPromise = runAgentSession(
+      "sid-stop-notice",
+      "prompt",
+      platform,
+      "chat-stop-notice",
+      Date.now(),
+      "claude",
+    );
+
+    await vi.waitFor(() => {
+      expect(activePrompts.get("sid-stop-notice")?.closeSession).toBeTypeOf("function");
+    });
+    expect(platform.sendText).not.toHaveBeenCalledWith("chat-stop-notice", "会话已停止。");
+
+    const ok = stopSession("sid-stop-notice");
+    expect(ok).toBe(true);
+    expect(closeSession).toHaveBeenCalledTimes(1);
+
+    await runPromise;
+
+    expect(platform.sendText).toHaveBeenCalledWith("chat-stop-notice", "会话已停止。");
+    expect(activePrompts.has("sid-stop-notice")).toBe(false);
+  });
+
   it("re-injects IM skill capabilities for each resumed Claude prompt", async () => {
     const platform = mockPlatform("feishu");
     setSessionPlatform(platform);
@@ -569,6 +630,58 @@ describe("unified display loop terminal card update", () => {
     );
     expect(displayCards.get("chat-terminal")?.sequence).toBe(110);
   });
+
+  it("keeps terminal display and retries final text when sending fails", async () => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const platform = mockPlatform("feishu");
+    platform.cardUpdate = vi.fn(async () => {});
+    platform.sendText = vi.fn()
+      .mockResolvedValueOnce(false)
+      .mockResolvedValueOnce(true);
+    setSessionPlatform(platform);
+
+    bindChatToSession("sid-terminal-retry", "chat-terminal-retry");
+    recordLastActiveChat("sid-terminal-retry", "chat-terminal-retry");
+    sessionInfoMap.set("chat-terminal-retry", {
+      sessionId: "sid-terminal-retry",
+      turnCount: 1,
+      lastContextTokens: 0,
+      startTime: 0,
+      tool: "claude",
+    });
+    displayCards.set("chat-terminal-retry", {
+      cardId: "card-terminal-retry",
+      sequence: 4,
+      cardBusy: false,
+      cardCreatedAt: Date.now(),
+      lastSentContent: "",
+      streamErrorNotified: false,
+      sessionId: "sid-terminal-retry",
+      turnCount: 1,
+      dotCount: 0,
+    });
+    mockStreamStates.set("sid-terminal-retry", {
+      accumulatedContent: "work log",
+      finalReply: "final answer",
+      status: "done",
+      turnCount: 1,
+    });
+
+    startUnifiedDisplayLoop();
+    await vi.advanceTimersByTimeAsync(3000);
+
+    expect(platform.cardUpdate).toHaveBeenCalledTimes(1);
+    expect(platform.sendText).toHaveBeenCalledTimes(1);
+    expect(displayCards.has("chat-terminal-retry")).toBe(true);
+    expect(mockStreamStates.get("sid-terminal-retry")?.finalReplySentTurn).toBeUndefined();
+
+    await vi.advanceTimersByTimeAsync(3000);
+
+    expect(platform.cardUpdate).toHaveBeenCalledTimes(1);
+    expect(platform.sendText).toHaveBeenCalledTimes(2);
+    expect(displayCards.has("chat-terminal-retry")).toBe(false);
+    expect(mockStreamStates.get("sid-terminal-retry")?.finalReplySentTurn).toBe(1);
+  });
 });
 
 describe("rebuildBindingsFromRegistry", () => {

package/src/__tests__/stop-session.test.ts

@@ -41,9 +41,13 @@ vi.mock("../stream-state.ts", () => ({
 import { stopSession } from "../session.ts";
 import { activePrompts } from "../session-chat-binding.ts";
 
-function seedRunningSession(sid: string, accumulated = "partial output"): AbortController {
+function seedRunningSession(
+  sid: string,
+  accumulated = "partial output",
+  closeSession?: () => void,
+): AbortController {
   const controller = new AbortController();
-  activePrompts.set(sid, { controller, stopped: false, startTime: Date.now() });
+  activePrompts.set(sid, { controller, stopped: false, startTime: Date.now(), closeSession });
   stateStore.set(sid, {
     sessionId: sid,
     status: "running",
@@ -123,4 +127,14 @@ describe("stopSession 行为护栏", () => {
     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);
+  });
 });

package/src/feishu-api.ts

@@ -757,6 +757,9 @@ export async function sendTextReply(
     config: { wide_screen_mode: true },
     elements: [{ tag: "markdown", content: wrappedText }],
   });
+  const timeoutMs = 15_000;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
     const resp = await fetch(`${BASE_URL}/im/v1/messages?receive_id_type=chat_id`, {
       method: "POST",
@@ -769,8 +772,16 @@ export async function sendTextReply(
         msg_type: "interactive",
         content: card,
       }),
+      signal: controller.signal,
     });
-    const data = (await resp.json().catch(() => ({}))) as { code: number; msg?: string; data?: { message_id?: string } };
+    const respText = await resp.text();
+    let data: { code: number; msg?: string; data?: { message_id?: string } };
+    try {
+      data = JSON.parse(respText);
+    } catch {
+      console.error(`[${ts()}] [SEND] text FAIL: chatId=${chatId} invalid JSON status=${resp.status}`);
+      return false;
+    }
     if (data.code !== 0) {
       console.error(`[${ts()}] [SEND] text FAIL: chatId=${chatId} code=${data.code} msg="${data.msg ?? ""}"`);
       return false;
@@ -778,8 +789,14 @@ export async function sendTextReply(
     console.log(`[${ts()}] [SEND] text OK: chatId=${chatId} msgId=${data.data?.message_id ?? "N/A"}`);
     return true;
   } catch (err) {
+    if ((err as Error).name === "AbortError") {
+      console.error(`[${ts()}] [SEND] text TIMEOUT after ${timeoutMs}ms: chatId=${chatId}`);
+      return false;
+    }
     console.error(`[${ts()}] [SEND] text FAIL: chatId=${chatId} ${(err as Error).message}`);
     return false;
+  } finally {
+    clearTimeout(timer);
   }
 }
 

package/src/orchestrator.ts

@@ -778,8 +778,7 @@ export async function handleCommand(
       logTrace(tid, "BRANCH", { cmd: "/stop" });
       if (stopSession(sessionId)) {
         console.log(`[${ts()}] [STOP] User sent /stop, session=${sessionId}`);
-        await platform.sendText(chatId, "会话已停止。").catch(() => {});
-        logTrace(tid, "DONE", { outcome: "stopped" });
+        logTrace(tid, "DONE", { outcome: "stop_requested" });
       } else {
         await platform
           .sendText(chatId, "当前没有正在进行的会话。")

package/src/session.ts

@@ -1247,7 +1247,10 @@ export async function runAgentSession(
         });
       }
       const active1 = getLastActiveChat(sessionId) ?? getChatsForSession(sessionId)[0];
-      if (active1) platform.setChatAvatar(active1, tool, "idle").catch(() => {});
+      if (active1) {
+        await platform.sendText(active1, "会话已停止。").catch(() => {});
+        platform.setChatAvatar(active1, tool, "idle").catch(() => {});
+      }
       console.log(`[${ts()}] Session ${sessionId} stopped (content chunks: ${state.chunkCount})`);
       if (tid) logTrace(tid, "SESSION_END", { sessionId, outcome: "stopped", chunks: state.chunkCount });
     } else if (wasAbnormalExit) {
@@ -1300,17 +1303,21 @@ const CARD_ROTATE_MS = 9 * 60 * 1000;
 export function startUnifiedDisplayLoop(): void {
   if (unifiedDisplayLoopHandle !== null) return;
 
+  let tickRunning = false;
   const interval = setInterval(() => {
     void (async () => {
-      for (const [chatId, display] of displayCards) {
-        if (display.cardBusy) continue;
-
-        const sessionId = display.sessionId;
-        const state = await readStreamState(sessionId);
-        if (!state) {
-          displayCards.delete(chatId);
-          continue;
-        }
+      if (tickRunning) return;
+      tickRunning = true;
+      try {
+        for (const [chatId, display] of displayCards) {
+          if (display.cardBusy) continue;
+
+          const sessionId = display.sessionId;
+          const state = await readStreamState(sessionId);
+          if (!state) {
+            displayCards.delete(chatId);
+            continue;
+          }
 
         // 交叉验证：chat 当前绑定的 session 是否仍是 display 记录的 session。
         // 若 chat 已被切换到其他 session（如 /newh），旧 display 必须停推。
@@ -1375,45 +1382,57 @@ export function startUnifiedDisplayLoop(): void {
               ) {
                 continue;
               }
-              const nextSeq = display.sequence + 1;
-              const { title: headerTitle, template: headerTemplate } = formatTerminalHeader(state.status);
-              const cardContent = truncateContent(state.accumulatedContent + state.finalReply) || " ";
-              const doneCard = buildProgressCard(cardContent, { showStop: false, headerTitle, headerTemplate });
-              let terminalCardUpdateAccepted = false;
-              await p.cardUpdate(display.cardId, doneCard, nextSeq).then(() => {
-                display.sequence = nextSeq;
-                terminalCardUpdateAccepted = true;
-              }).catch(err => {
-                console.error(`[${ts()}] [DISPLAY] terminal cardUpdate failed: ${(err as Error).message}`);
-                if (isCardKitSequenceConflict(err)) {
+              const terminalCardAlreadyUpdated =
+                display.lastSentAccLen === state.accumulatedContent.length &&
+                display.lastSentFinalReply === state.finalReply;
+              let terminalCardUpdateAccepted = terminalCardAlreadyUpdated;
+              if (!terminalCardAlreadyUpdated) {
+                const nextSeq = display.sequence + 1;
+                const { title: headerTitle, template: headerTemplate } = formatTerminalHeader(state.status);
+                const cardContent = truncateContent(state.accumulatedContent + state.finalReply) || " ";
+                const doneCard = buildProgressCard(cardContent, { showStop: false, headerTitle, headerTemplate });
+                await p.cardUpdate(display.cardId, doneCard, nextSeq).then(() => {
                   display.sequence = nextSeq;
                   terminalCardUpdateAccepted = true;
+                }).catch(err => {
+                  console.error(`[${ts()}] [DISPLAY] terminal cardUpdate failed: ${(err as Error).message}`);
+                  if (isCardKitSequenceConflict(err)) {
+                    display.sequence = nextSeq;
+                    terminalCardUpdateAccepted = true;
+                  }
+                });
+                if (terminalCardUpdateAccepted) {
+                  display.lastSentAccLen = state.accumulatedContent.length;
+                  display.lastSentFinalReply = state.finalReply;
                 }
-              });
+              }
 
               // 若 session 仍在 activePrompts 中，说明 runAgentSession 的 finally
               // 还没执行，当前 stream state 可能是 stopSession fire-and-forget
               // 写入的，finalReply 滞后于内存态。卡片已更新为终态外观，但不发送
               // 文本、不删除 display 条目，留给 finally 落盘后的下一次 tick 处理。
               if (promptStillActive) {
-                if (terminalCardUpdateAccepted) {
-                  display.lastSentAccLen = state.accumulatedContent.length;
-                  display.lastSentFinalReply = state.finalReply;
-                }
                 continue;
               }
 
-              const finalSt = turnFinalStatus(state.status);
-              finalizeTurnCards(sessionId, state.turnCount, finalSt).catch(() => {});
-              displayCards.delete(chatId);
+              let terminalTextDelivered = true;
               if (state.finalReply) {
                 if (!isFinalReplySentForTurn(state)) {
-                  await sendFinalReplyTextOnce(p, chatId, sessionId, state.turnCount, state.finalReply);
+                  terminalTextDelivered = await sendFinalReplyTextOnce(p, chatId, sessionId, state.turnCount, state.finalReply);
                 }
               } else if (state.accumulatedContent.trim()) {
                 const short = truncateContent(state.accumulatedContent, 30, 4000);
-                await p.sendText(chatId, `[生成过程]\n${short}`).catch(() => {});
+                terminalTextDelivered = await p.sendText(chatId, `[生成过程]\n${short}`).then((ok) => ok !== false).catch(() => false);
               }
+
+              if (!terminalTextDelivered) {
+                console.error(`[${ts()}] [DISPLAY] terminal text send failed, keep display for retry: chatId=${chatId} session=${sessionId} turn=${state.turnCount}`);
+                continue;
+              }
+
+              const finalSt = turnFinalStatus(state.status);
+              finalizeTurnCards(sessionId, state.turnCount, finalSt).catch(() => {});
+              displayCards.delete(chatId);
             }
             p.setChatAvatar(chatId, state.tool, "idle").catch(() => {});
             console.log(`[${ts()}] [DISPLAY] unified loop deleted display for ${chatId} (terminal: ${state.status})`);
@@ -1561,9 +1580,12 @@ export function startUnifiedDisplayLoop(): void {
               }
             }
           }
-        } catch (err) {
-          console.error(`[${ts()}] Display loop error for ${chatId}: ${(err as Error).message}`);
+          } catch (err) {
+            console.error(`[${ts()}] Display loop error for ${chatId}: ${(err as Error).message}`);
+          }
         }
+      } finally {
+        tickRunning = false;
       }
     })().catch((err: unknown) => {
       const e = err instanceof Error ? err : new Error(String(err));
@@ -1604,6 +1626,11 @@ export function stopSession(sessionId: string): boolean {
   prompt.stopped = true;
   clearPromptProcessMonitor(sessionId);
   cancelQueuedMessage(sessionId);
+  try {
+    prompt.closeSession?.();
+  } catch (err) {
+    console.warn(`[${ts()}] [STOP] closeSession failed for ${sessionId}: ${(err as Error).message}`);
+  }
   prompt.controller.abort();
 
   // 强制杀死 CLI 子进程。controller.abort() 只在 for-await 收到下一条