chatccc 0.2.88 → 0.2.90

package/package.json

@@ -1,63 +1,63 @@
-{
-  "name": "chatccc",
-  "version": "0.2.88",
-  "description": "Feishu bot bridge for Claude Code",
-  "license": "Apache-2.0",
-  "type": "module",
-  "main": "./src/index.ts",
-  "bin": {
-    "chatccc": "bin/chatccc.mjs"
-  },
-  "files": [
-    "src/",
-    "bin/",
-    "scripts/postinstall-sharp-check.mjs",
-    "demo/ilink_echo_probe.ts",
-    "im-skills/",
-    "images/img_readme_*.jpg",
-    "images/img_readme_*.png",
-    "images/avatars/status_*.png",
-    "images/avatars/badges/",
-    "package.json",
-    "README.md",
-    "config.sample.json"
-  ],
-  "scripts": {
-    "dev": "tsx src/index.ts",
-    "chatccc": "tsx src/index.ts",
-    "start": "tsx src/index.ts",
-    "demo:bot-test": "tsx demo/bot_test.ts",
-    "demo:bot-test:local": "tsx demo/bot_test.ts --local",
-    "demo:create-group": "tsx src/index.ts",
-    "demo:create-group:local": "tsx src/index.ts --local",
-    "demo:permission-check": "tsx demo/permission_check.ts",
-    "demo:claude-hi": "tsx demo/claude_say_hi.ts",
-    "demo:codex-hi": "tsx demo/codex_say_hi.ts",
-    "demo:ilink-echo": "tsx demo/ilink_echo_probe.ts",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "postinstall": "node scripts/postinstall-sharp-check.mjs"
-  },
-  "dependencies": {
-    "@ai-sdk/openai-compatible": "^2.0.47",
-    "@anthropic-ai/claude-agent-sdk": "0.2.133",
-    "@larksuiteoapi/node-sdk": "^1.59.0",
-    "@openilink/openilink-sdk-node": "^0.6.0",
-    "ai": "^6.0.184",
-    "nodemailer": "^8.0.7",
-    "qrcode-terminal": "^0.12.0",
-    "sharp": "^0.34.5",
-    "tsx": "^4.0.0",
-    "ws": "^8.18.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "@types/qrcode-terminal": "^0.12.2",
-    "@types/ws": "^8.18.1",
-    "typescript": "^5.0.0",
-    "vitest": "^3.2.4"
-  },
-  "engines": {
-    "node": ">=20"
-  }
-}
+{
+  "name": "chatccc",
+  "version": "0.2.90",
+  "description": "Feishu bot bridge for Claude Code",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./src/index.ts",
+  "bin": {
+    "chatccc": "bin/chatccc.mjs"
+  },
+  "files": [
+    "src/",
+    "bin/",
+    "scripts/postinstall-sharp-check.mjs",
+    "demo/ilink_echo_probe.ts",
+    "im-skills/",
+    "images/img_readme_*.jpg",
+    "images/img_readme_*.png",
+    "images/avatars/status_*.png",
+    "images/avatars/badges/",
+    "package.json",
+    "README.md",
+    "config.sample.json"
+  ],
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "chatccc": "tsx src/index.ts",
+    "start": "tsx src/index.ts",
+    "demo:bot-test": "tsx demo/bot_test.ts",
+    "demo:bot-test:local": "tsx demo/bot_test.ts --local",
+    "demo:create-group": "tsx src/index.ts",
+    "demo:create-group:local": "tsx src/index.ts --local",
+    "demo:permission-check": "tsx demo/permission_check.ts",
+    "demo:claude-hi": "tsx demo/claude_say_hi.ts",
+    "demo:codex-hi": "tsx demo/codex_say_hi.ts",
+    "demo:ilink-echo": "tsx demo/ilink_echo_probe.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "postinstall": "node scripts/postinstall-sharp-check.mjs"
+  },
+  "dependencies": {
+    "@ai-sdk/openai-compatible": "^2.0.47",
+    "@anthropic-ai/claude-agent-sdk": "0.2.133",
+    "@larksuiteoapi/node-sdk": "^1.59.0",
+    "@openilink/openilink-sdk-node": "^0.6.0",
+    "ai": "^6.0.184",
+    "nodemailer": "^8.0.7",
+    "qrcode-terminal": "^0.12.0",
+    "sharp": "^0.34.5",
+    "tsx": "^4.0.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/qrcode-terminal": "^0.12.2",
+    "@types/ws": "^8.18.1",
+    "typescript": "^5.0.0",
+    "vitest": "^3.2.4"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/src/session-chat-binding.ts

@@ -130,6 +130,8 @@ export interface DisplayCardState {
   cardCreatedAt: number;
   lastSentContent: string;
   streamErrorNotified: boolean;
+  /** 所属 turn */
+  turnCount: number;
   /** 卡片轮转时记录的基线，轮转后只展示增量 */
   rotationAccLen?: number;
   rotationFinalReply?: string;
@@ -137,8 +139,6 @@ export interface DisplayCardState {
   lastSentAccLen?: number;
   /** WeChat delta: 上次发送时的 finalReply */
   lastSentFinalReply?: string;
-  /** 上次 loop 读取到的 turnCount，用于检测轮次切换 */
-  lastTurnCount?: number;
 }
 
 export const displayCards = new Map<string, DisplayCardState>();

package/src/session.ts

@@ -38,6 +38,7 @@ function compressWechatDisplayText(text: string): string {
   return [...lines.slice(0, 5), "...", ...lines.slice(-5)].join("\n");
 }
 import { readStreamState, writeStreamState, createEmptyStreamState, fixStaleStreamStates } from "./stream-state.ts";
+import { addCardToTurn, finalizeTurnCards, markCardDone } from "./turn-cards.ts";
 import {
   bindChatToSession,
   unbindChatFromSession,
@@ -791,10 +792,77 @@ export async function runAgentSession(
     running: true,
   });
 
+  // 在覆盖 stream state 前，先终结上一轮的展示卡片并发送最终回复。
+  // 竞态根因：上一轮 finally 写入 "done" 状态后，200ms setTimeout 即启动
+  // 新一轮 runAgentSession，立即覆盖为 "running" 状态并 kill 旧 display
+  // loop。旧 loop 的 3s 间隔 tick 只有约 6.7% 概率在 200ms 窗口内命中，
+  // 导致 finalReply 丢失、完成卡片空白。此处主动读取上一轮终端状态完成
+  // 卡片终结和回复发送，不依赖 display loop 时序，保证"先发完上一个回答
+  // 再开始缓存问题对应的任务"。
+  const prevState = await readStreamState(sessionId);
+  if (prevState && prevState.status !== "running") {
+    const displayChatId = pickDisplayChat(sessionId);
+    if (displayChatId) {
+      const pp = platformForChat(displayChatId);
+      const display = displayCards.get(displayChatId);
+      const oldLoopExisted = displayLoops.has(sessionId);
+
+      if (display && pp) {
+        // 旧 display loop 被 kill 前来不及终结卡片 → 现在终结
+        while (display.cardBusy) await new Promise(r => setTimeout(r, 20));
+        const nextSeq = display.sequence + 1;
+        const headerTitle = prevState.status === "stopped" ? "已停止" : "完成";
+        const headerTemplate = prevState.status === "stopped" ? "red" : undefined;
+        const cardContent = prevState.accumulatedContent || " ";
+        const doneCard = buildProgressCard(cardContent, { showStop: false, headerTitle, headerTemplate });
+        await pp.cardUpdate(display.cardId, doneCard, nextSeq).catch(() => {});
+        displayCards.delete(displayChatId);
+
+        // 持久化：标记上一轮所有卡片为终态
+        const finalStatus = prevState.status === "stopped" ? "stopped" : "done";
+        finalizeTurnCards(sessionId, prevState.turnCount, finalStatus).catch(() => {});
+
+        if (prevState.finalReply) {
+          await pp.sendText(displayChatId, prevState.finalReply).catch(() => {});
+        }
+        pp.setChatAvatar(displayChatId, prevState.tool, "idle").catch(() => {});
+      } else if (oldLoopExisted && pp && prevState.finalReply) {
+        // display loop 存在但尚未创建卡片（极快轮次），至少发送 finalReply
+        await pp.sendText(displayChatId, prevState.finalReply).catch(() => {});
+      }
+      // else: display loop 已自行终结（displayCards 无记录）→ 无需处理
+    }
+  }
+
   // 初始化 stream-state.json
   const initialState = createEmptyStreamState(sessionId, cwd, tool, nextTurnCount);
   await writeStreamState(initialState);
 
+  // 为新 turn 创建第一张展示卡片，同时注册到 turn-cards 持久化。
+  // 放在 ensureDisplayLoop 之前，确保卡片立即可见（不等 3s 首次 tick）。
+  const displayChatIdForNew = pickDisplayChat(sessionId);
+  if (displayChatIdForNew) {
+    const ppNew = platformForChat(displayChatIdForNew);
+    if (ppNew && ppNew.kind !== "wechat") {
+      const cardId = await ppNew.cardCreate(
+        buildProgressCard("", { showStop: true, headerTitle: "生成中..." }),
+      ).catch(() => null);
+      if (cardId) {
+        await ppNew.cardSend(displayChatIdForNew, cardId).catch(() => null);
+        displayCards.set(displayChatIdForNew, {
+          cardId,
+          sequence: 1,
+          cardBusy: false,
+          cardCreatedAt: Date.now(),
+          lastSentContent: "",
+          streamErrorNotified: false,
+          turnCount: nextTurnCount,
+        });
+        addCardToTurn(sessionId, nextTurnCount, cardId).catch(() => {});
+      }
+    }
+  }
+
   // 启动 display loop
   ensureDisplayLoop(sessionId);
 
@@ -1040,6 +1108,8 @@ export function ensureDisplayLoop(sessionId: string): void {
               const cardContent = state.accumulatedContent || " ";
               const doneCard = buildProgressCard(cardContent, { showStop: false, headerTitle, headerTemplate });
               await p.cardUpdate(display.cardId, doneCard, nextSeq).catch(() => {});
+              const finalSt = state.status === "stopped" ? "stopped" : "done";
+              finalizeTurnCards(sessionId, state.turnCount, finalSt).catch(() => {});
               displayCards.delete(chatId);
             }
             if (state.finalReply) {
@@ -1106,6 +1176,7 @@ export function ensureDisplayLoop(sessionId: string): void {
           } else {
             // 非 WeChat: 卡片流程
             if (!display) {
+              // 兜底：runAgentSession 应已创建卡片，若没有则补建
               const cardId = await p.cardCreate(buildProgressCard("", { showStop: true, headerTitle: "生成中..." })).catch(() => null);
               if (cardId) {
                 await p.cardSend(chatId, cardId).catch(() => null);
@@ -1116,57 +1187,38 @@ export function ensureDisplayLoop(sessionId: string): void {
                   cardCreatedAt: Date.now(),
                   lastSentContent: "",
                   streamErrorNotified: false,
-                  lastTurnCount: state.turnCount,
+                  turnCount: state.turnCount,
                 });
+                addCardToTurn(sessionId, state.turnCount, cardId).catch(() => {});
               }
             } else {
               if (display.cardBusy) return;
 
-              // 检测轮次切换：turnCount 变化说明上一轮已完成、本 tick 是新轮，
-              // 但上一轮的 display 卡片因 setImmediate/setTimeout 时序问题
-              // 还没被终结分支清除。此处主动终结旧卡、创建新卡。
-              if (display.lastTurnCount !== undefined && display.lastTurnCount !== state.turnCount) {
-                display.cardBusy = true;
-                try {
-                  const doneSeq = display.sequence + 1;
-                  const doneCard = buildProgressCard("", { showStop: false, headerTitle: "完成" });
-                  await p.cardUpdate(display.cardId, doneCard, doneSeq).catch(() => {});
-                  displayCards.delete(chatId);
-                } catch (_) { /* ignore */ }
-                display.cardBusy = false;
-                // 新建卡片
-                const cardId = await p.cardCreate(buildProgressCard("", { showStop: true, headerTitle: "生成中..." })).catch(() => null);
-                if (cardId) {
-                  await p.cardSend(chatId, cardId).catch(() => null);
-                  displayCards.set(chatId, {
-                    cardId,
-                    sequence: 1,
-                    cardBusy: false,
-                    cardCreatedAt: Date.now(),
-                    lastSentContent: "",
-                    streamErrorNotified: false,
-                    lastTurnCount: state.turnCount,
-                  });
-                }
+              // 守卫：display 归属的 turn 与当前 stream state 不一致。
+              // 正常流程 runAgentSession 会终结旧 turn 并建新卡，
+              // 此处仅兜底处理异常情况（如进程重启后 display 残留）。
+              if (display.turnCount !== state.turnCount) {
+                console.log(`[${ts()}] [DISPLAY] turn mismatch for ${chatId}: display.turnCount=${display.turnCount} state.turnCount=${state.turnCount}, resetting`);
+                displayCards.delete(chatId);
                 return;
               }
 
-              // 更新当前 turn 的 lastTurnCount
-              display.lastTurnCount = state.turnCount;
-
               // 卡片轮转
               if (Date.now() - display.cardCreatedAt > CARD_ROTATE_MS) {
                 display.cardBusy = true;
                 try {
                   const oldSeqBase = display.sequence;
-                  const oldCard = buildProgressCard("", { showStop: false, headerTitle: "完成" });
+                  const oldContent = state.accumulatedContent + state.finalReply;
+                  const oldCard = buildProgressCard(truncateContent(oldContent) || " ", { showStop: false, headerTitle: "完成" });
                   await p.cardUpdate(display.cardId, oldCard, oldSeqBase + 1).catch(() => {});
+                  markCardDone(sessionId, display.turnCount, display.cardId).catch(() => {});
                   const newCardId = await p.cardCreate(buildProgressCard(
                     "",
                     { showStop: true, headerTitle: "生成中..." },
                   ));
                   if (newCardId) {
                     await p.cardSend(chatId, newCardId);
+                    addCardToTurn(sessionId, display.turnCount, newCardId).catch(() => {});
                     display.cardId = newCardId;
                     display.sequence = 1;
                     display.cardCreatedAt = Date.now();

package/src/turn-cards.ts

@@ -0,0 +1,118 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+import { USER_DATA_DIR, ts } from "./config.ts";
+
+// ---------------------------------------------------------------------------
+// turn-cards.json — 每个 session 的卡片归属持久化
+// 记录每个 turn 有哪些卡片（轮转会产生多张），以及每张卡片的状态
+// ---------------------------------------------------------------------------
+
+export const TURNS_DIR = join(USER_DATA_DIR, "state", "turns");
+
+export interface TurnCardEntry {
+  cardId: string;
+  status: "active" | "done" | "stopped";
+  createdAt: number;
+}
+
+export interface TurnCardsFile {
+  sessionId: string;
+  turns: { turnCount: number; cards: TurnCardEntry[] }[];
+}
+
+function getTurnCardsPath(sessionId: string): string {
+  return join(TURNS_DIR, `${sessionId}.json`);
+}
+
+export function createEmptyTurnCards(sessionId: string): TurnCardsFile {
+  return { sessionId, turns: [] };
+}
+
+export async function readTurnCards(sessionId: string): Promise<TurnCardsFile | null> {
+  try {
+    const raw = await readFile(getTurnCardsPath(sessionId), "utf-8");
+    const parsed = JSON.parse(raw) as TurnCardsFile;
+    if (parsed && typeof parsed.sessionId === "string" && Array.isArray(parsed.turns)) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export async function writeTurnCards(sessionId: string, data: TurnCardsFile): Promise<void> {
+  try {
+    const filePath = getTurnCardsPath(sessionId);
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+  } catch (err) {
+    console.error(`[${ts()}] Failed to write turn-cards for ${sessionId}: ${(err as Error).message}`);
+  }
+}
+
+/** 向指定 turn 追加一张卡片并持久化。若 turn 不存在则创建。 */
+export async function addCardToTurn(
+  sessionId: string,
+  turnCount: number,
+  cardId: string,
+): Promise<void> {
+  const data = (await readTurnCards(sessionId)) ?? createEmptyTurnCards(sessionId);
+  let turn = data.turns.find(t => t.turnCount === turnCount);
+  if (!turn) {
+    turn = { turnCount, cards: [] };
+    data.turns.push(turn);
+  }
+  turn.cards.push({ cardId, status: "active", createdAt: Date.now() });
+  await writeTurnCards(sessionId, data);
+}
+
+/** 将指定 turn 的所有 active 卡片标记为终态并持久化。返回被标记的 cardId 列表。 */
+export async function finalizeTurnCards(
+  sessionId: string,
+  turnCount: number,
+  finalStatus: "done" | "stopped",
+): Promise<string[]> {
+  const data = await readTurnCards(sessionId);
+  if (!data) return [];
+  const turn = data.turns.find(t => t.turnCount === turnCount);
+  if (!turn) return [];
+  const finalized: string[] = [];
+  for (const card of turn.cards) {
+    if (card.status === "active") {
+      card.status = finalStatus;
+      finalized.push(card.cardId);
+    }
+  }
+  if (finalized.length > 0) {
+    await writeTurnCards(sessionId, data);
+  }
+  return finalized;
+}
+
+/** 将指定 turn 中的一张 active 卡片标记为 done（轮转时用），并持久化。 */
+export async function markCardDone(
+  sessionId: string,
+  turnCount: number,
+  cardId: string,
+): Promise<void> {
+  const data = await readTurnCards(sessionId);
+  if (!data) return;
+  const turn = data.turns.find(t => t.turnCount === turnCount);
+  if (!turn) return;
+  const card = turn.cards.find(c => c.cardId === cardId && c.status === "active");
+  if (!card) return;
+  card.status = "done";
+  await writeTurnCards(sessionId, data);
+}
+
+/** 清理 session 的 turn-cards 文件 */
+export async function removeTurnCards(sessionId: string): Promise<void> {
+  try {
+    const { unlink } = await import("node:fs/promises");
+    await unlink(getTurnCardsPath(sessionId));
+  } catch {
+    // 文件不存在，忽略
+  }
+}