chatccc 0.2.171 → 0.2.173

package/package.json

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

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,139 @@ describe("runAgentSession process monitor", () => {
       expect.stringContaining("进程异常结束"),
     );
   });
+
+  it("recreates the progress card when the initial CardKit send fails", async () => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const platform = mockPlatform("feishu");
+    platform.cardCreate = vi.fn()
+      .mockResolvedValueOnce("bad-card")
+      .mockResolvedValueOnce("good-card");
+    platform.cardSend = vi.fn()
+      .mockRejectedValueOnce(new Error("cardid is invalid"))
+      .mockResolvedValueOnce("message-good");
+    setSessionPlatform(platform);
+    bindChatToSession("sid-card-retry", "chat-card-retry");
+    recordLastActiveChat("sid-card-retry", "chat-card-retry");
+
+    const adapter: ToolAdapter = {
+      displayName: "Claude Code",
+      sessionDescPrefix: "Claude Code Session:",
+      createSession: async () => ({ sessionId: "sid-card-retry" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
+      closeSession: async () => {},
+      prompt: async function* () {
+        yield { type: "assistant", blocks: [{ type: "text", text: "done" }] };
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
+
+    await runAgentSession("sid-card-retry", "prompt", platform, "chat-card-retry", Date.now(), "claude");
+
+    expect(platform.cardCreate).toHaveBeenCalledTimes(2);
+    expect(platform.cardSend).toHaveBeenNthCalledWith(1, "chat-card-retry", "bad-card");
+    expect(platform.cardSend).toHaveBeenNthCalledWith(2, "chat-card-retry", "good-card");
+    expect(displayCards.get("chat-card-retry")?.cardId).toBe("good-card");
+    expect(platform.sendText).not.toHaveBeenCalledWith(
+      "chat-card-retry",
+      "生成中卡片发送失败，结果将以文本形式发送。",
+    );
+  });
+
+  it("does not register an invisible progress card and sends the final text fallback", async () => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const platform = mockPlatform("feishu");
+    platform.cardCreate = vi.fn()
+      .mockResolvedValueOnce("bad-card-1")
+      .mockResolvedValueOnce("bad-card-2");
+    platform.cardSend = vi.fn()
+      .mockRejectedValueOnce(new Error("cardid is invalid"))
+      .mockRejectedValueOnce(new Error("cardid is invalid again"));
+    setSessionPlatform(platform);
+    bindChatToSession("sid-card-fallback", "chat-card-fallback");
+    recordLastActiveChat("sid-card-fallback", "chat-card-fallback");
+
+    const adapter: ToolAdapter = {
+      displayName: "Claude Code",
+      sessionDescPrefix: "Claude Code Session:",
+      createSession: async () => ({ sessionId: "sid-card-fallback" }),
+      getSessionInfo: async (sid) => ({ sessionId: sid, cwd: "F:\\repo" }),
+      closeSession: async () => {},
+      prompt: async function* () {
+        yield { type: "assistant", blocks: [{ type: "text", text: "final answer" }] };
+      },
+    };
+    _setAdapterForToolForTest("claude", adapter);
+
+    await runAgentSession("sid-card-fallback", "prompt", platform, "chat-card-fallback", Date.now(), "claude");
+
+    expect(displayCards.has("chat-card-fallback")).toBe(false);
+    expect(platform.sendText).toHaveBeenCalledWith(
+      "chat-card-fallback",
+      "生成中卡片发送失败，结果将以文本形式发送。",
+    );
+    expect(platform.sendText).toHaveBeenCalledWith("chat-card-fallback", "final answer");
+    expect(mockStreamStates.get("sid-card-fallback")?.finalReplySentTurn).toBe(1);
+  });
+
+  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);

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/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

@@ -81,6 +81,36 @@ async function sendFinalReplyTextOnce(
   return sent;
 }
 
+async function createVisibleProgressCard(
+  platform: PlatformAdapter,
+  chatId: string,
+  sessionId: string,
+  turnCount: number,
+  notifyFailureText?: string,
+): Promise<string | null> {
+  for (let attempt = 1; attempt <= 2; attempt++) {
+    let cardId: string | null = null;
+    try {
+      cardId = await platform.cardCreate(
+        buildProgressCard("", { showStop: true, headerTitle: "生成中..." }),
+      );
+      if (!cardId) throw new Error("empty card id");
+      await platform.cardSend(chatId, cardId);
+      await addCardToTurn(sessionId, turnCount, cardId);
+      return cardId;
+    } catch (err) {
+      console.error(
+        `[${ts()}] [DISPLAY] progress card send attempt ${attempt} failed: chatId=${chatId} cardId=${cardId || "(none)"} ${(err as Error).message}`,
+      );
+    }
+  }
+
+  if (notifyFailureText) {
+    await platform.sendText(chatId, notifyFailureText).catch(() => {});
+  }
+  return null;
+}
+
 // ---------------------------------------------------------------------------
 // Shared state (imported by index.ts)
 // ---------------------------------------------------------------------------
@@ -1053,11 +1083,14 @@ export async function runAgentSession(
   if (displayChatIdForNew) {
     const ppNew = platformForChat(displayChatIdForNew);
     if (ppNew && ppNew.kind !== "wechat") {
-      const cardId = await ppNew.cardCreate(
-        buildProgressCard("", { showStop: true, headerTitle: "生成中..." }),
-      ).catch(() => null);
+      const cardId = await createVisibleProgressCard(
+        ppNew,
+        displayChatIdForNew,
+        sessionId,
+        nextTurnCount,
+        "生成中卡片发送失败，结果将以文本形式发送。",
+      );
       if (cardId) {
-        await ppNew.cardSend(displayChatIdForNew, cardId).catch(() => null);
         displayCards.set(displayChatIdForNew, {
           cardId,
           sequence: 1,
@@ -1069,7 +1102,6 @@ export async function runAgentSession(
           turnCount: nextTurnCount,
           dotCount: 0,
         });
-        addCardToTurn(sessionId, nextTurnCount, cardId).catch(() => {});
       }
     } else if (ppNew && ppNew.kind === "wechat") {
       // WeChat: 无卡片，但需要 display entry 追踪已发送内容
@@ -1247,7 +1279,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) {
@@ -1281,7 +1316,14 @@ export async function runAgentSession(
         });
       }
       const active2 = getLastActiveChat(sessionId) ?? getChatsForSession(sessionId)[0];
-      if (active2) platform.setChatAvatar(active2, tool, "idle").catch(() => {});
+      if (active2) {
+        const terminalState = await readStreamState(sessionId);
+        if (finalReply && !displayCards.has(active2) && (!terminalState || !isFinalReplySentForTurn(terminalState))) {
+          const pp = platformForChat(active2) ?? platform;
+          await sendFinalReplyTextOnce(pp, active2, sessionId, nextTurnCount, finalReply);
+        }
+        platform.setChatAvatar(active2, tool, "idle").catch(() => {});
+      }
       console.log(`[${ts()}] Session ${sessionId} stream complete (content chunks: ${state.chunkCount})`);
       if (tid) logTrace(tid, "SESSION_END", { sessionId, chunks: state.chunkCount, finalTextLen: finalReply.length });
     }
@@ -1479,28 +1521,33 @@ export function startUnifiedDisplayLoop(): void {
               if (Date.now() - display.cardCreatedAt > CARD_ROTATE_MS) {
                 display.cardBusy = true;
                 try {
+                  const newCardId = await createVisibleProgressCard(
+                    p,
+                    chatId,
+                    sessionId,
+                    display.turnCount,
+                    display.streamErrorNotified ? undefined : "生成中卡片发送失败，结果将继续更新在上一张卡片中。",
+                  );
+                  if (!newCardId) {
+                    display.streamErrorNotified = true;
+                    continue;
+                  }
                   const oldSeqBase = display.sequence;
                   const oldContent = state.accumulatedContent + state.finalReply;
                   const oldCard = buildProgressCard(truncateContent(oldContent) || " ", { showStop: false, headerTitle: "生成中（上轮）" });
-                  await p.cardUpdate(display.cardId, oldCard, oldSeqBase + 1).catch(err => {
+                  await p.cardUpdate(display.cardId, oldCard, oldSeqBase + 1).then(() => {
+                    display.sequence = oldSeqBase + 1;
+                  }).catch(err => {
                     console.error(`[${ts()}] [DISPLAY] rotation old cardUpdate failed: ${(err as Error).message}`);
                   });
                   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();
-                    display.rotationAccLen = state.accumulatedContent.length;
-                    display.rotationFinalReply = state.finalReply;
-                    display.lastSentContent = "";
-                    display.streamErrorNotified = false;
-                  }
+                  display.cardId = newCardId;
+                  display.sequence = 1;
+                  display.cardCreatedAt = Date.now();
+                  display.rotationAccLen = state.accumulatedContent.length;
+                  display.rotationFinalReply = state.finalReply;
+                  display.lastSentContent = "";
+                  display.streamErrorNotified = false;
                 } catch (err) {
                   console.error(`[${ts()}] [CARDIKT] rotation FAIL for ${chatId}: ${(err as Error).message}`);
                 } finally {
@@ -1623,6 +1670,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 收到下一条