chatccc 0.2.169 → 0.2.171

package/package.json

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

package/src/__tests__/cardkit.test.ts

@@ -0,0 +1,60 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { updateCardKitCard } from "../cardkit.ts";
+
+function abortError(): Error {
+  const err = new Error("aborted");
+  err.name = "AbortError";
+  return err;
+}
+
+describe("CardKit request timeout", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+  });
+
+  it("aborts a hung card update so display.cardBusy can be released", 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 update = expect(updateCardKitCard("token", "card-1", "{}", 7))
+      .rejects.toThrow("updateCard cardId=card-1 seq=7 timeout after 15000ms");
+    await vi.advanceTimersByTimeAsync(15_000);
+
+    await update;
+    expect(fetchMock).toHaveBeenCalledWith(
+      expect.stringContaining("/cardkit/v1/cards/card-1"),
+      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 update = expect(updateCardKitCard("token", "card-2", "{}", 8))
+      .rejects.toThrow("updateCard cardId=card-2 seq=8 timeout after 15000ms");
+    await vi.advanceTimersByTimeAsync(15_000);
+
+    await update;
+  });
+});

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

@@ -569,6 +569,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/cardkit.ts

@@ -6,17 +6,41 @@ import { BASE_URL, fileLog, ts } from "./config.ts";
 // 由飞书客户端自行渲染增量文本，用户看到的是逐字出现的效果。
 // 参考: https://open.feishu.cn/document/uYjLw4iNukDO6YDN4ITM4MjM
 
+const CARDKIT_REQUEST_TIMEOUT_MS = 15_000;
+
+async function fetchCardKit(
+  url: string,
+  init: Parameters<typeof fetch>[1],
+  operation: string,
+): Promise<{ resp: Response; respText: string }> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), CARDKIT_REQUEST_TIMEOUT_MS);
+  try {
+    const resp = await fetch(url, { ...init, signal: controller.signal });
+    const respText = await resp.text();
+    return { resp, respText };
+  } catch (err) {
+    if ((err as Error).name === "AbortError") {
+      console.error(`[${ts()}] [CARDIKT] ${operation} TIMEOUT after ${CARDKIT_REQUEST_TIMEOUT_MS}ms`);
+      fileLog.flush();
+      throw new Error(`${operation} timeout after ${CARDKIT_REQUEST_TIMEOUT_MS}ms`);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 export async function createCardKitCard(token: string, cardJson: string): Promise<string> {
   const body = JSON.stringify({ type: "card_json", data: cardJson });
-  const resp = await fetch(`${BASE_URL}/cardkit/v1/cards`, {
+  const { resp, respText } = await fetchCardKit(`${BASE_URL}/cardkit/v1/cards`, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${token}`,
       "Content-Type": "application/json",
     },
     body,
-  });
-  const respText = await resp.text();
+  }, "createCard");
   let data: { code: number; msg?: string; data?: { card_id?: string } };
   try {
     data = JSON.parse(respText);
@@ -40,15 +64,14 @@ export async function setCardKitSettings(
   settings: Record<string, unknown>,
   sequence: number
 ): Promise<void> {
-  const resp = await fetch(`${BASE_URL}/cardkit/v1/cards/${cardId}/settings`, {
+  const { resp, respText } = await fetchCardKit(`${BASE_URL}/cardkit/v1/cards/${cardId}/settings`, {
     method: "PATCH",
     headers: {
       Authorization: `Bearer ${token}`,
       "Content-Type": "application/json",
     },
     body: JSON.stringify({ settings: JSON.stringify(settings), sequence }),
-  });
-  const respText = await resp.text();
+  }, `settings cardId=${cardId} seq=${sequence}`);
   let data: { code: number; msg?: string };
   try { data = JSON.parse(respText); } catch {
     console.error(`[${ts()}] [CARDIKT] settings FAIL: invalid JSON cardId=${cardId} seq=${sequence} status=${resp.status}`);
@@ -70,7 +93,7 @@ export async function streamCardKitElement(
   content: string,
   sequence: number
 ): Promise<void> {
-  const resp = await fetch(
+  const { resp, respText } = await fetchCardKit(
     `${BASE_URL}/cardkit/v1/cards/${cardId}/elements/${elementId}/content`,
     {
       method: "PUT",
@@ -79,9 +102,9 @@ export async function streamCardKitElement(
         "Content-Type": "application/json",
       },
       body: JSON.stringify({ content, sequence }),
-    }
+    },
+    `streamElement cardId=${cardId} element=${elementId} seq=${sequence}`,
   );
-  const respText = await resp.text();
   let data: { code: number; msg?: string };
   try { data = JSON.parse(respText); } catch {
     console.error(`[${ts()}] [CARDIKT] streamElement FAIL: invalid JSON cardId=${cardId} element=${elementId} seq=${sequence} status=${resp.status}`);
@@ -103,15 +126,14 @@ export async function updateCardKitCard(
   cardJson: string,
   sequence: number
 ): Promise<void> {
-  const resp = await fetch(`${BASE_URL}/cardkit/v1/cards/${cardId}`, {
+  const { resp, respText } = await fetchCardKit(`${BASE_URL}/cardkit/v1/cards/${cardId}`, {
     method: "PUT",
     headers: {
       Authorization: `Bearer ${token}`,
       "Content-Type": "application/json",
     },
     body: JSON.stringify({ card: { type: "card_json", data: cardJson }, sequence }),
-  });
-  const respText = await resp.text();
+  }, `updateCard cardId=${cardId} seq=${sequence}`);
   let data: { code: number; msg?: string };
   try { data = JSON.parse(respText); } catch {
     console.error(`[${ts()}] [CARDIKT] updateCard FAIL: invalid JSON cardId=${cardId} seq=${sequence} status=${resp.status}`);
@@ -133,15 +155,14 @@ export async function sendCardKitMessage(
 ): Promise<string> {
   const payload = { receive_id: chatId, msg_type: "interactive", content: JSON.stringify({ type: "card", data: { card_id: cardId } }) };
   const url = `${BASE_URL}/im/v1/messages?receive_id_type=chat_id`;
-  const resp = await fetch(url, {
+  const { resp, respText } = await fetchCardKit(url, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${token}`,
       "Content-Type": "application/json",
     },
     body: JSON.stringify(payload),
-  });
-  const respText = await resp.text();
+  }, `sendMessage cardId=${cardId} chatId=${chatId}`);
   let data: { code: number; msg?: string; data?: { message_id?: string } };
   try { data = JSON.parse(respText); } catch {
     console.error(`[${ts()}] [CARDIKT] sendMessage FAIL: invalid JSON cardId=${cardId} chatId=${chatId} status=${resp.status}`);

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

@@ -1300,17 +1300,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 +1379,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 +1577,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));