chatccc 0.2.57 → 0.2.58

package/README.md

@@ -32,7 +32,7 @@ ChatCCC 把本地 AI 编程工具接入即时通讯软件。你可以在手机
 | 会话形态 | 群聊，一群一会话 | 私聊，一对一 |
 | 消息展示 | CardKit 卡片，流式更新 | 纯文本，增量推送 |
 | `/new` | 自动创建新群并绑定新会话 | 在当前私聊里创建新会话 |
-| 多会话并行 | 直接切换不同群 | 需要在同一私聊内切换上下文 |
+| 多会话并行 | 直接切换不同群 | 支持并行，使用切换指令后未完成的任务会继续在后台进行，但不如飞书直观方便 |
 | 群管理 | 支持创建、重命名、解散、头像 | 不支持 |
 | 接入成本 | 需要配置飞书应用 | 启动后扫码登录 |
 
@@ -158,9 +158,9 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
   "claude": {
     "enabled": false,
     "defaultAgent": true,
-    "model": "claude-sonnet-4-6",
-    "subagentModel": "",
-    "effort": "",
+    "model": "claude-sonnet-4-6",
+    "subagentModel": "",
+    "effort": "",
     "apiKey": "",
     "baseUrl": ""
   },
@@ -189,9 +189,9 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | `gitTimeoutSeconds` | `/git` 命令超时时间，默认 180 秒 |
 | `*.enabled` | 是否启用对应 AI Agent |
 | `*.defaultAgent` | `/new` 未指定 Agent 时使用哪个工具 |
-| `cursor.path` / `codex.path` | CLI 可执行文件路径；留空时自动探测或使用 PATH |
-| `claude.model` / `claude.subagentModel` | Claude Code 主模型 / subagent 模型；`subagentModel` 仅在第三方 API 模式下注入 `CLAUDE_CODE_SUBAGENT_MODEL` |
-| `claude.apiKey` / `claude.baseUrl` | 第三方 Anthropic 兼容网关配置；官方 Claude 用户留空 |
+| `cursor.path` / `codex.path` | CLI 可执行文件路径；留空时自动探测或使用 PATH |
+| `claude.model` / `claude.subagentModel` | Claude Code 主模型 / subagent 模型；`subagentModel` 仅在第三方 API 模式下注入 `CLAUDE_CODE_SUBAGENT_MODEL` |
+| `claude.apiKey` / `claude.baseUrl` | 第三方 Anthropic 兼容网关配置；官方 Claude 用户留空 |
 
 > 当前 ChatCCC 以 `bypassPermissions` 模式运行，会跳过 Agent 操作确认。请只在可信环境中使用。
 

package/package.json

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

package/src/__tests__/orchestrator.test.ts

@@ -0,0 +1,168 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import type { PlatformAdapter } from "../platform-adapter.ts";
+import type { SessionInfo, ToolAdapter } from "../adapters/adapter-interface.ts";
+
+const mockStreamStates = new Map<string, { status: "running" | "done" | "stopped"; finalReply: string }>();
+
+vi.mock("../im-skills.ts", () => ({
+  buildImSkillsPrompt: async () => "",
+  exportSkillSubDocs: async () => {},
+}));
+
+vi.mock("../stream-state.ts", () => ({
+  readStreamState: async (sessionId: string) => {
+    const state = mockStreamStates.get(sessionId);
+    if (!state) return null;
+    return {
+      sessionId,
+      status: state.status,
+      accumulatedContent: "",
+      finalReply: state.finalReply,
+      chunkCount: 0,
+      turnCount: 1,
+      contextTokens: 0,
+      updatedAt: Date.now(),
+      cwd: "F:\\repo",
+      tool: "claude",
+    };
+  },
+  writeStreamState: async (state: { sessionId: string; status: "running" | "done" | "stopped"; finalReply: string }) => {
+    mockStreamStates.set(state.sessionId, {
+      status: state.status,
+      finalReply: state.finalReply,
+    });
+  },
+  createEmptyStreamState: (sessionId: string, cwd: string, tool: string, turnCount: number) => ({
+    sessionId,
+    status: "running" as const,
+    accumulatedContent: "",
+    finalReply: "",
+    chunkCount: 0,
+    turnCount,
+    contextTokens: 0,
+    updatedAt: Date.now(),
+    cwd,
+    tool,
+  }),
+  fixStaleStreamStates: async () => {},
+}));
+
+import { handleCommand } from "../orchestrator.ts";
+import {
+  _clearAdapterCacheForTest,
+  _resetSessionRegistryFileForTest,
+  _resetSessionToolsFileForTest,
+  _setAdapterForToolForTest,
+  _setSessionRegistryFileForTest,
+  _setSessionToolsFileForTest,
+  recordSessionRegistry,
+  resetState,
+} from "../session.ts";
+import { activePrompts, resetBindingState } from "../session-chat-binding.ts";
+
+function mockPlatform(): PlatformAdapter {
+  return {
+    kind: "wechat",
+    sendText: vi.fn(async () => true),
+    sendCard: vi.fn(async () => true),
+    sendRawCard: vi.fn(async () => true),
+    createGroup: vi.fn(async () => "unused-group"),
+    updateChatInfo: vi.fn(async () => {}),
+    getChatInfo: vi.fn(async () => ({ name: "微信会话", description: "" })),
+    disbandChat: vi.fn(async () => {}),
+    setChatAvatar: vi.fn(async () => {}),
+    extractSessionInfo: vi.fn(() => null),
+    cardCreate: vi.fn(async () => "card-id"),
+    cardSend: vi.fn(async () => "message-id"),
+    cardUpdate: vi.fn(async () => {}),
+  };
+}
+
+function mockAdapter(): ToolAdapter {
+  return {
+    displayName: "Claude",
+    sessionDescPrefix: "Claude Session:",
+    createSession: async () => ({ sessionId: "sid-wechat" }),
+    prompt: async function* () {
+      yield {
+        type: "assistant",
+        blocks: [{ type: "text", text: "done" }],
+      };
+    },
+    getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
+      sessionId,
+      cwd: "F:\\repo",
+    }),
+    closeSession: async () => {},
+  };
+}
+
+describe("handleCommand WeChat processing ack", () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    vi.useFakeTimers();
+    tempDir = await mkdtemp(join(tmpdir(), "chatccc-orchestrator-"));
+    _setSessionRegistryFileForTest(join(tempDir, "session-registry.json"));
+    _setSessionToolsFileForTest(join(tempDir, "sessions.json"));
+    resetState();
+    resetBindingState();
+    mockStreamStates.clear();
+    _setAdapterForToolForTest("claude", mockAdapter());
+  });
+
+  afterEach(async () => {
+    resetState();
+    resetBindingState();
+    _clearAdapterCacheForTest();
+    _resetSessionRegistryFileForTest();
+    _resetSessionToolsFileForTest();
+    vi.useRealTimers();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it("does not send the WeChat processing ack when the session is already running", 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, "继续说明", "wx-chat", "wx-user", Date.now(), "p2p");
+
+    expect(platform.sendText).not.toHaveBeenCalledWith("wx-chat", "生成中...");
+    expect(platform.sendCard).toHaveBeenCalledWith(
+      "wx-chat",
+      "生成中",
+      "该会话正在生成回复中，请等待完成后再发送新消息。",
+      "yellow",
+    );
+  });
+
+  it("sends the WeChat processing ack after the busy check for normal prompts", async () => {
+    const platform = mockPlatform();
+    await recordSessionRegistry({
+      chatId: "wx-chat",
+      sessionId: "sid-wechat",
+      tool: "claude",
+      chatName: "ready-session",
+      running: false,
+    });
+
+    await handleCommand(platform, "继续说明", "wx-chat", "wx-user", Date.now(), "p2p");
+
+    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
+  });
+});

package/src/orchestrator.ts

@@ -72,13 +72,21 @@ export function cwdDisplayName(cwd: string): string {
   return trimmed.split(/[\\/]/).filter(Boolean).pop() || trimmed || "cwd";
 }
 
-export function sessionChatName(left: string, cwd: string): string {
-  return `${left}-${cwdDisplayName(cwd)}`;
-}
-
-function isUntitledSessionChatName(name: string): boolean {
-  return name === "新会话" || name.startsWith("新会话-");
-}
+export function sessionChatName(left: string, cwd: string): string {
+  return `${left}-${cwdDisplayName(cwd)}`;
+}
+
+function isUntitledSessionChatName(name: string): boolean {
+  return name === "新会话" || name.startsWith("新会话-");
+}
+
+function shouldSendWechatProcessingAck(
+  platform: PlatformAdapter,
+  textLower: string,
+  chatType: string,
+): boolean {
+  return platform.kind === "wechat" && chatType === "p2p" && !textLower.startsWith("/");
+}
 
 // ---------------------------------------------------------------------------
 // handleCommand — 平台无关的命令分发
@@ -971,11 +979,11 @@ export async function handleCommand(
     }
 
     // 并发检查：同一 session 只能有一个活跃 prompt
-    if (isSessionRunning(sessionId)) {
-      logTrace(tid, "BLOCKED", {
-        outcome: "session_busy",
-        sessionId,
-      });
+    if (isSessionRunning(sessionId)) {
+      logTrace(tid, "BLOCKED", {
+        outcome: "session_busy",
+        sessionId,
+      });
       console.log(
         `[${ts()}] [BLOCKED] Session ${sessionId} is already generating, rejecting message from chat ${chatId}`,
       );
@@ -984,13 +992,17 @@ export async function handleCommand(
         "生成中",
         "该会话正在生成回复中，请等待完成后再发送新消息。",
         "yellow",
-      );
-      return;
-    }
-
-    try {
-      logTrace(tid, "RESUME", { sessionId, tool: descriptionTool });
-      await resumeAndPrompt(
+      );
+      return;
+    }
+
+    if (shouldSendWechatProcessingAck(platform, textLower, chatType)) {
+      await platform.sendText(chatId, "生成中...").catch(() => {});
+    }
+
+    try {
+      logTrace(tid, "RESUME", { sessionId, tool: descriptionTool });
+      await resumeAndPrompt(
         sessionId,
         text,
         platform,

package/src/wechat-platform.ts

@@ -500,21 +500,9 @@ async function handleWechatMessage(
   // 用户回复，重置 claw 连发计数
   consecutiveSendCount.set(chatId, 0);
 
-  // 非指令消息：立即发送"生成中..."，让用户知道消息已收到并正在处理
-  if (text && !text.startsWith("/") && ilinkWire) {
-    const ctxToken = contextTokenMap.get(chatId);
-    if (ctxToken) {
-      ilinkWire.sendText(chatId, "生成中...", ctxToken).catch(() => {});
-    } else {
-      ilinkWire.push(chatId, "生成中...").catch(() => {});
-    }
-    // "生成中..." 计为第1条连发消息
-    consecutiveSendCount.set(chatId, 1);
-  }
-
-  // WeChat 中所有会话都视为 p2p，/new 复用 p2p 路径（等同飞书 /newh 效果）
-  // 不 await：避免长 prompt 阻塞后续消息处理（如 /cd、/stop 等命令）
-  handler(text, chatId, chatId, msgTimestamp, "p2p").catch((err) => {
+  // WeChat 中所有会话都视为 p2p，/new 复用 p2p 路径（等同飞书 /newh 效果）
+  // 不 await：避免长 prompt 阻塞后续消息处理（如 /cd、/stop 等命令）
+  handler(text, chatId, chatId, msgTimestamp, "p2p").catch((err) => {
     platformLog(`消息处理失败: ${(err as Error).stack ?? (err as Error).message}`);
   });
 }