chatccc 0.2.73 → 0.2.75

package/package.json

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

package/src/__tests__/orchestrator.test.ts

@@ -142,13 +142,14 @@ describe("handleCommand WeChat processing ack", () => {
 
     await handleCommand(platform, "继续说明", "wx-chat", "wx-user", Date.now(), "p2p");
 
+    // 不再发"生成中"卡片，改为入队文本通知
     expect(platform.sendText).not.toHaveBeenCalledWith("wx-chat", "生成中...");
-    expect(platform.sendCard).toHaveBeenCalledWith(
+    expect(platform.sendText).toHaveBeenCalledWith(
       "wx-chat",
-      "生成中",
-      "该会话正在生成回复中，请等待完成后再发送新消息。也可以发送 /stop 结束，已完成的步骤不会丢失。",
-      "yellow",
+      "当前会话正在生成中，你的消息已进入缓存队列，生成完成后会立即处理。发送 /cancel 可取消缓存。",
     );
+    // sendCard 不再被调用（WeChat 用 sendText）
+    expect(platform.sendCard).not.toHaveBeenCalled();
   });
 
   it("sends the WeChat processing ack after the busy check for normal prompts", async () => {

package/src/__tests__/platform-startup.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+
+import { buildPlatformStartupPlan } from "../platform-startup.ts";
+
+describe("buildPlatformStartupPlan", () => {
+  it("starts WeChat iLink without requiring Feishu when Feishu is disabled", () => {
+    expect(buildPlatformStartupPlan({ feishuEnabled: false, ilinkEnabled: true })).toEqual({
+      startFeishu: false,
+      startIlink: true,
+    });
+  });
+
+  it("can start both platforms when both are enabled", () => {
+    expect(buildPlatformStartupPlan({ feishuEnabled: true, ilinkEnabled: true })).toEqual({
+      startFeishu: true,
+      startIlink: true,
+    });
+  });
+});

package/src/cards.ts

@@ -346,6 +346,47 @@ export function buildSessionsCard(sessions: Array<{
   });
 }
 
+// 队列缓存卡片（消息已进入缓存队列，带取消按钮）
+export function buildQueuedCard(text: string): string {
+  const preview = text.length > 100 ? text.slice(0, 100) + "…" : text;
+  return JSON.stringify({
+    config: { wide_screen_mode: true },
+    header: { template: "blue", title: { content: "消息已进入缓存队列", tag: "plain_text" } },
+    elements: [
+      { tag: "div", text: { tag: "lark_md", content: `当前会话正在生成中，你的消息已进入缓存队列，生成完成后会立即处理。\n\n> ${preview}` } },
+      { tag: "hr" },
+      {
+        tag: "action",
+        actions: [{
+          tag: "button",
+          text: { tag: "plain_text", content: "取消缓存（/cancel）" },
+          type: "danger",
+          value: { action: "cancel" },
+        }],
+      },
+    ],
+  });
+}
+
+// 队列满卡片（提示 /stop 或 /cancel）
+export function buildQueueFullCard(): string {
+  return JSON.stringify({
+    config: { wide_screen_mode: true },
+    header: { template: "yellow", title: { content: "消息队列已满", tag: "plain_text" } },
+    elements: [
+      { tag: "div", text: { tag: "lark_md", content: "当前缓存队列中已有消息等待处理，请等待或发送指令：\n- **/stop** — 停止当前生成\n- **/cancel** — 取消队列中的消息" } },
+      { tag: "hr" },
+      {
+        tag: "action",
+        actions: [
+          { tag: "button", text: { tag: "plain_text", content: "取消缓存（/cancel）" }, type: "danger", value: { action: "cancel" } },
+          { tag: "button", text: { tag: "plain_text", content: "停止生成（/stop）" }, type: "default", value: { action: "stop" } },
+        ],
+      },
+    ],
+  });
+}
+
 // 状态卡片（带关闭按钮）
 export function buildStatusCard(statusText: string, template = "blue"): string {
   return JSON.stringify({

package/src/index.ts

@@ -29,6 +29,7 @@ import WebSocket from "ws";
 
 import { appendStartupTrace, attachRelayWebSocket, ensureSingleInstance, freeRelayListenPort, installCrashLogging, waitForPortFree } from "./shared.ts";
 import { createUiRouter, setExtraApiHandler, setReloadConfigHook, startSetupMode } from "./web-ui.ts";
+import { buildPlatformStartupPlan } from "./platform-startup.ts";
 import { makeTraceId, logTrace } from "./trace.ts";
 import {
   CHATCCC_PORT,
@@ -94,6 +95,7 @@ import {
 } from "./session.ts";
 import {
   rebuildSessionChatsFromRegistry,
+  setQueueConsumer,
 } from "./session-chat-binding.ts";
 import { fixStaleStreamStates } from "./stream-state.ts";
 import { handleCommand, type PlatformAdapter } from "./orchestrator.ts";
@@ -155,6 +157,13 @@ const feishuPlatform = createFeishuAdapter();
 const wechatPlatform = createWechatAdapter();
 setSessionPlatform(feishuPlatform);
 
+// 注册队列消费回调：session 生成完成后自动处理缓存消息
+setQueueConsumer((platform, msg) => {
+  handleCommand(platform, msg.text, msg.chatId, msg.openId, msg.msgTimestamp, msg.chatType, msg.traceId).catch(err =>
+    console.error(`[${ts()}] Queue consume failed: ${(err as Error).message}`)
+  );
+});
+
 // ---------------------------------------------------------------------------
 // Event types
 // ---------------------------------------------------------------------------
@@ -275,7 +284,7 @@ function parseCardAction(data: unknown): CardActionResult | null {
   }
   if (!cmd) return null;
 
-  const CMD_MAP: Record<string, string> = { stop: "/stop", new: "/new", "new claude": "/new claude", "new cursor": "/new cursor", "new codex": "/new codex", restart: "/restart", status: "/status", cd: "/cd", sessions: "/sessions", newh: "/newh" };
+  const CMD_MAP: Record<string, string> = { stop: "/stop", cancel: "/cancel", new: "/new", "new claude": "/new claude", "new cursor": "/new cursor", "new codex": "/new codex", restart: "/restart", status: "/status", cd: "/cd", sessions: "/sessions", newh: "/newh" };
   let text = CMD_MAP[cmd] ?? "";
   if (cmd === "cd" && typeof action.value === "object" && action.value !== null) {
     const path = (action.value as Record<string, string>).path;
@@ -668,6 +677,36 @@ async function startWechatSupervisor(): Promise<void> {
   console.log("[WX] 微信 iLink 平台已停止。");
 }
 
+async function startConfiguredPlatforms(
+  httpServer: Server,
+  options: { failOnFeishuError: boolean },
+): Promise<void> {
+  const plan = buildPlatformStartupPlan({
+    feishuEnabled: FEISHU_ENABLED,
+    ilinkEnabled: ILINK_ENABLED,
+  });
+
+  if (plan.startFeishu) {
+    try {
+      await startBotService({ httpServer, port: CHATCCC_PORT });
+    } catch (err) {
+      if (options.failOnFeishuError) throw err;
+      console.error(`\n[飞书] 启动失败: ${(err as Error).message}`);
+      console.error("[飞书] 微信等其他平台不受影响，将继续启动。\n");
+    }
+  } else {
+    console.log("[飞书] 平台未启用，跳过飞书启动。");
+  }
+
+  if (plan.startIlink) {
+    startWechatSupervisor().catch((err) =>
+      console.error(`[WX] 微信 supervisor 异常退出: ${(err as Error).message}`),
+    );
+  } else {
+    console.log("[WX] 微信 iLink 未启用，跳过微信启动。");
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Main
 // ---------------------------------------------------------------------------
@@ -784,11 +823,11 @@ async function main(): Promise<void> {
             appIdMaskAfterReload: maskAppId(APP_ID),
           });
           try {
-            await startBotService({ httpServer, port: CHATCCC_PORT });
+            await startConfiguredPlatforms(httpServer, { failOnFeishuError: true });
             installShutdownHandlers(httpServer);
             return { ok: true };
           } catch (err) {
-            appendStartupTrace("setup-activate: startBotService failed", {
+            appendStartupTrace("setup-activate: startConfiguredPlatforms failed", {
               message: (err as Error).message,
             });
             return { ok: false, error: (err as Error).message };
@@ -822,19 +861,7 @@ async function main(): Promise<void> {
     process.exit(1);
   });
 
-  if (FEISHU_ENABLED) {
-    try {
-      await startBotService({ httpServer, port: CHATCCC_PORT });
-    } catch (err) {
-      console.error(`\n[飞书] 启动失败: ${(err as Error).message}`);
-      console.error("[飞书] 微信等其他平台不受影响，将继续启动。\n");
-    }
-  }
-
-  // 启动微信 iLink 平台（后台运行，不阻塞飞书）
-  startWechatSupervisor().catch((err) =>
-    console.error(`[WX] 微信 supervisor 异常退出: ${(err as Error).message}`),
-  );
+  await startConfiguredPlatforms(httpServer, { failOnFeishuError: false });
 
   installShutdownHandlers(httpServer);
 }

package/src/orchestrator.ts

@@ -32,6 +32,8 @@ import {
   buildCdContent,
   buildCdCard,
   buildSessionsCard,
+  buildQueuedCard,
+  buildQueueFullCard,
 } from "./cards.ts";
 import {
   formatGitResult,
@@ -60,6 +62,8 @@ import {
   isSessionRunning,
   displayCards,
   recordLastActiveChat,
+  enqueueMessage,
+  cancelQueuedMessage,
 } from "./session-chat-binding.ts";
 export { type PlatformAdapter } from "./platform-adapter.ts";
 import type { PlatformAdapter } from "./platform-adapter.ts";
@@ -306,6 +310,7 @@ export async function handleCommand(
       if (oldRecord?.sessionId && oldRecord.sessionId !== sessionId) {
         unbindChatFromSession(oldRecord.sessionId, chatId);
         displayCards.delete(chatId);
+        cancelQueuedMessage(oldRecord.sessionId);
       }
       bindChatToSession(sessionId, chatId);
       sessionInfoMap.set(chatId, {
@@ -590,6 +595,19 @@ export async function handleCommand(
       return;
     }
 
+    if (textLower === "/cancel") {
+      logTrace(tid, "BRANCH", { cmd: "/cancel" });
+      if (cancelQueuedMessage(sessionId)) {
+        console.log(`[${ts()}] [CANCEL] Queue cancelled for session=${sessionId}`);
+        await platform.sendText(chatId, "已取消缓存队列中的消息。").catch(() => {});
+        logTrace(tid, "DONE", { outcome: "cancelled" });
+      } else {
+        await platform.sendText(chatId, "当前缓存队列中没有消息。").catch(() => {});
+        logTrace(tid, "DONE", { outcome: "cancel_no_queue" });
+      }
+      return;
+    }
+
     if (textLower === "/status") {
       logTrace(tid, "BRANCH", { cmd: "/status" });
       const status = await getSessionStatus(chatId);
@@ -980,21 +998,32 @@ export async function handleCommand(
       return;
     }
 
-    // 并发检查：同一 session 只能有一个活跃 prompt
+    // 并发检查：同一 session 只能有一个活跃 prompt，多余消息进入队列
     if (isSessionRunning(sessionId)) {
-      logTrace(tid, "BLOCKED", {
-        outcome: "session_busy",
-        sessionId,
+      const queued = enqueueMessage(sessionId, {
+        text, chatId, openId, msgTimestamp, chatType, traceId: tid,
       });
-      console.log(
-        `[${ts()}] [BLOCKED] Session ${sessionId} is already generating, rejecting message from chat ${chatId}`,
-      );
-      await platform.sendCard(
-        chatId,
-        "生成中",
-        "该会话正在生成回复中，请等待完成后再发送新消息。也可以发送 /stop 结束，已完成的步骤不会丢失。",
-        "yellow",
-      );
+      if (queued) {
+        logTrace(tid, "QUEUED", { sessionId });
+        console.log(
+          `[${ts()}] [QUEUED] Session ${sessionId} is busy, message from chat ${chatId} enqueued`,
+        );
+        if (platform.kind === "wechat") {
+          await platform.sendText(chatId, "当前会话正在生成中，你的消息已进入缓存队列，生成完成后会立即处理。发送 /cancel 可取消缓存。").catch(() => {});
+        } else {
+          await platform.sendRawCard(chatId, buildQueuedCard(text)).catch(() => {});
+        }
+      } else {
+        logTrace(tid, "QUEUE_FULL", { sessionId });
+        console.log(
+          `[${ts()}] [QUEUE_FULL] Session ${sessionId} queue full, rejecting message from chat ${chatId}`,
+        );
+        if (platform.kind === "wechat") {
+          await platform.sendText(chatId, "当前缓存队列中已有消息等待处理，请等待或发送 /stop（停止生成）或 /cancel（取消缓存）。").catch(() => {});
+        } else {
+          await platform.sendRawCard(chatId, buildQueueFullCard()).catch(() => {});
+        }
+      }
       return;
     }
 

package/src/platform-startup.ts

@@ -0,0 +1,16 @@
+export interface PlatformStartupPlanInput {
+  feishuEnabled: boolean;
+  ilinkEnabled: boolean;
+}
+
+export interface PlatformStartupPlan {
+  startFeishu: boolean;
+  startIlink: boolean;
+}
+
+export function buildPlatformStartupPlan(input: PlatformStartupPlanInput): PlatformStartupPlan {
+  return {
+    startFeishu: input.feishuEnabled,
+    startIlink: input.ilinkEnabled,
+  };
+}

package/src/session-chat-binding.ts

@@ -5,6 +5,8 @@
 // 由 session.ts 在初始化时调用 rebuildSessionChatsFromRegistry 重建
 // ---------------------------------------------------------------------------
 
+import type { PlatformAdapter } from "./platform-adapter.ts";
+
 const sessionChatsMap = new Map<string, Set<string>>();
 
 /** 从 registry 数据重建映射（由 session.ts 调用，避免循环依赖） */
@@ -123,10 +125,60 @@ export const displayCards = new Map<string, DisplayCardState>();
 /** displayLoops: sessionId → 展示循环的 stop 函数 */
 export const displayLoops = new Map<string, () => void>();
 
+// ---------------------------------------------------------------------------
+// queuedMessages: sessionId → 缓存消息（生成中排队，队列最大长度 1）
+// ---------------------------------------------------------------------------
+
+export interface QueuedMessage {
+  text: string;
+  chatId: string;
+  openId: string;
+  msgTimestamp: number;
+  chatType: string;
+  traceId?: string;
+}
+
+export const queuedMessages = new Map<string, QueuedMessage>();
+
+export function enqueueMessage(sessionId: string, msg: QueuedMessage): boolean {
+  if (queuedMessages.has(sessionId)) return false;
+  queuedMessages.set(sessionId, msg);
+  return true;
+}
+
+export function dequeueMessage(sessionId: string): QueuedMessage | undefined {
+  const msg = queuedMessages.get(sessionId);
+  queuedMessages.delete(sessionId);
+  return msg;
+}
+
+export function cancelQueuedMessage(sessionId: string): boolean {
+  return queuedMessages.delete(sessionId);
+}
+
+export function hasQueuedMessage(sessionId: string): boolean {
+  return queuedMessages.has(sessionId);
+}
+
+// ---------------------------------------------------------------------------
+// 队列消费回调（由 index.ts 注入，避免 session.ts → orchestrator.ts 循环依赖）
+// ---------------------------------------------------------------------------
+
+let onConsumeQueuedMessage: ((platform: PlatformAdapter, msg: QueuedMessage) => void) | null = null;
+
+export function setQueueConsumer(fn: (platform: PlatformAdapter, msg: QueuedMessage) => void): void {
+  onConsumeQueuedMessage = fn;
+}
+
+export function consumeQueuedMessage(platform: PlatformAdapter, msg: QueuedMessage): void {
+  onConsumeQueuedMessage?.(platform, msg);
+}
+
 export function resetBindingState(): void {
   sessionChatsMap.clear();
   lastActiveChatMap.clear();
   activePrompts.clear();
+  queuedMessages.clear();
   displayCards.clear();
   for (const stop of displayLoops.values()) stop();
   displayLoops.clear();

package/src/session.ts

@@ -50,6 +50,9 @@ import {
   recordLastActiveChat,
   getLastActiveChat,
   pickDisplayChat,
+  dequeueMessage,
+  consumeQueuedMessage,
+  cancelQueuedMessage,
 } from "./session-chat-binding.ts";
 
 // ---------------------------------------------------------------------------
@@ -575,6 +578,7 @@ export async function switchChatBinding(args: SwitchChatBindingArgs): Promise<Sw
   if (oldSessionId) {
     unbindChatFromSession(oldSessionId, chatId);
     displayCards.delete(chatId);
+    cancelQueuedMessage(oldSessionId);
   }
   bindChatToSession(newSessionId, chatId);
   recordLastActiveChat(newSessionId, chatId);
@@ -854,6 +858,15 @@ export async function runAgentSession(
     const wasStopped = prompt?.stopped ?? false;
     activePrompts.delete(sessionId);
 
+    // 消费队列中的缓存消息（异步，不阻塞后续清理）
+    const queued = dequeueMessage(sessionId);
+    if (queued) {
+      console.log(`[${ts()}] [QUEUE] Consuming queued message for session ${sessionId}: "${queued.text.slice(0, 50)}"`);
+      setImmediate(() => {
+        consumeQueuedMessage(platform, queued);
+      });
+    }
+
     // 写最终状态
     const finalStatus = wasStopped ? "stopped" : "done";
     const finalReply = pickFinalReply(state).trim();
@@ -1184,6 +1197,7 @@ export function stopSession(sessionId: string): boolean {
   const prompt = activePrompts.get(sessionId);
   if (!prompt) return false;
   prompt.stopped = true;
+  cancelQueuedMessage(sessionId);
   prompt.controller.abort();
   console.log(`[${ts()}] [STOP] Session ${sessionId} aborted`);
   return true;