chatccc 0.2.113 → 0.2.115

package/README.md

@@ -305,7 +305,7 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | `/newh` | 重置当前会话，保留工作目录 |
 | `/model` | 查看或切换当前会话的模型 |
 | `/stop` | 停止当前回复 |
-| `/status` | 查看当前会话状态 |
+| `/state` | 查看当前会话状态 |
 | `/cd` | 查看或设置当前会话工作目录 |
 | `/sessions` | 查看所有会话状态 |
 | `/git <子命令>` | 在当前会话工作目录执行 `git ...` 并回传输出 |

package/package.json

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

package/src/__tests__/card-plain-text.test.ts

@@ -32,7 +32,7 @@ describe("cardJsonToPlainText", () => {
 
     expect(text).toContain("# 生成中...");
     expect(text).toContain("stream body");
-    expect(text).toContain("/status");
+    expect(text).toContain("/state");
     expect(text).toContain("/stop");
   });
 

package/src/__tests__/cards.test.ts

@@ -107,7 +107,7 @@ describe("buildProgressCard", () => {
     const parsed = JSON.parse(card);
     const buttons = parsed.body.elements.filter((e: any) => e.tag === "button");
     expect(buttons).toHaveLength(2);
-    expect(buttons[0].text.content).toBe("查看状态（/status）");
+    expect(buttons[0].text.content).toBe("查看状态（/state）");
     expect(buttons[1].text.content).toBe("停止生成（/stop）");
   });
 

package/src/__tests__/claude-adapter.test.ts

@@ -369,7 +369,7 @@ describe("createClaudeAdapter", () => {
   // -------------------------------------------------------------------------
   // getSessionInfo 行为契约
   //   - cwd 决定 /git 是否可用
-  //   - model 用于 /status、/sessions 显示
+  //   - model 用于 /state、/sessions 显示
   // -------------------------------------------------------------------------
 
   it("getSessionInfo: store 中无该 sessionId 时只返回 sessionId", async () => {

package/src/__tests__/cursor-adapter.test.ts

@@ -296,7 +296,7 @@ describe("createCursorAdapter", () => {
   // -------------------------------------------------------------------------
   // getSessionInfo 行为契约
   //   - cwd 决定 /git 是否可用
-  //   - model 决定 /status、/sessions 显示的是否是 Cursor 真实模型
+  //   - model 决定 /state、/sessions 显示的是否是 Cursor 真实模型
   // -------------------------------------------------------------------------
 
   it("getSessionInfo: store 中无该 sessionId 时只返回 sessionId（cwd / model 都 undefined，让上层走错误分支）", async () => {
@@ -316,7 +316,7 @@ describe("createCursorAdapter", () => {
     expect(info?.model).toBeUndefined();
   });
 
-  it("getSessionInfo: store 同时有 cwd + model 时一并返回（这是 /status 显示真实模型的关键）", async () => {
+  it("getSessionInfo: store 同时有 cwd + model 时一并返回（这是 /state 显示真实模型的关键）", async () => {
     const store = createInMemoryMetaStore({
       "sid-known": { cwd: "F:/proj/Foo", model: "Composer 2 Fast" },
     });

package/src/__tests__/cursor-session-meta-store.test.ts

@@ -1,7 +1,7 @@
 // =============================================================================
 // cursor-session-meta-store.test.ts — sessionId→{cwd,model} 持久化的护栏单测
 // =============================================================================
-// 行为契约（与 cursor-adapter.getSessionInfo 配合，决定 /git、/status、/sessions
+// 行为契约（与 cursor-adapter.getSessionInfo 配合，决定 /git、/state、/sessions
 // 在 Cursor 会话上是否显示正确）：
 //   - 文件不存在 / 损坏 / 非法 schema 时 get 返回 undefined，不抛异常
 //   - set 部分合并：只覆盖非空字段，已有字段保持不变

package/src/__tests__/orchestrator.test.ts

@@ -10,6 +10,7 @@ const mockStreamStates = new Map<string, { status: "running" | "done" | "stopped
 
 vi.mock("../im-skills.ts", () => ({
   buildImSkillsPrompt: async () => "",
+  buildImSkillsPromptCached: async () => "",
   exportSkillSubDocs: async () => {},
 }));
 
@@ -59,20 +60,21 @@ import {
   _setAdapterForToolForTest,
   _setSessionRegistryFileForTest,
   _setSessionToolsFileForTest,
+  loadSessionRegistryForBinding,
   recordSessionRegistry,
   resetState,
 } from "../session.ts";
 import { activePrompts, resetBindingState } from "../session-chat-binding.ts";
 
-function mockPlatform(): PlatformAdapter {
+function mockPlatform(kind: "wechat" | "feishu" = "wechat"): PlatformAdapter {
   return {
-    kind: "wechat",
+    kind,
     sendText: vi.fn(async () => true),
     sendCard: vi.fn(async () => true),
     sendRawCard: vi.fn(async () => true),
-    createGroup: vi.fn(async () => "unused-group"),
+    createGroup: vi.fn(async () => "feishu-group"),
     updateChatInfo: vi.fn(async () => {}),
-    getChatInfo: vi.fn(async () => ({ name: "微信会话", description: "" })),
+    getChatInfo: vi.fn(async () => ({ name: kind === "wechat" ? "微信会话" : "飞书会话", description: "" })),
     disbandChat: vi.fn(async () => {}),
     setChatAvatar: vi.fn(async () => {}),
     extractSessionInfo: vi.fn(() => null),
@@ -82,15 +84,15 @@ function mockPlatform(): PlatformAdapter {
   };
 }
 
-function mockAdapter(): ToolAdapter {
+function mockAdapter(sessionId = "sid-wechat", promptText = "done"): ToolAdapter {
   return {
     displayName: "Claude",
     sessionDescPrefix: "Claude Session:",
-    createSession: async () => ({ sessionId: "sid-wechat" }),
+    createSession: vi.fn(async () => ({ sessionId })),
     prompt: async function* () {
       yield {
         type: "assistant",
-        blocks: [{ type: "text", text: "done" }],
+        blocks: [{ type: "text", text: promptText }],
       };
     },
     getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
@@ -166,4 +168,70 @@ describe("handleCommand WeChat processing ack", () => {
 
     expect(platform.sendText).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) {
+      yield {
+        type: "assistant" as const,
+        blocks: [{ type: "text" as const, text: `收到: ${userText}` }],
+      };
+    });
+    _setAdapterForToolForTest("cursor", {
+      displayName: "Claude",
+      sessionDescPrefix: "Claude Session:",
+      createSession: vi.fn(async () => ({ sessionId: "sid-feishu-new" })),
+      prompt,
+      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
+        sessionId,
+        cwd: "F:\\repo",
+      }),
+      closeSession: async () => {},
+    });
+    await recordSessionRegistry({
+      chatId: "feishu-p2p",
+      sessionId: "stale-sid",
+      tool: "claude",
+      chatName: "旧私聊绑定",
+      running: false,
+    });
+
+    await handleCommand(platform, "帮我看一下日志", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    expect(platform.createGroup).toHaveBeenCalledWith(expect.stringContaining("帮我看一下日志"), ["ou-user"]);
+    expect(platform.updateChatInfo).toHaveBeenCalledWith(
+      "feishu-group",
+      expect.stringContaining("帮我看一下日志"),
+      expect.stringContaining("sid-feishu-new"),
+    );
+    expect(prompt).toHaveBeenCalledWith(
+      "sid-feishu-new",
+      expect.stringContaining("帮我看一下日志"),
+      "F:\\repo",
+      expect.any(AbortSignal),
+      expect.any(Object),
+    );
+
+    const registry = await loadSessionRegistryForBinding();
+    expect(registry["feishu-p2p"]).toBeUndefined();
+    expect(registry["feishu-group"]?.sessionId).toBe("sid-feishu-new");
+  });
+
+  it("cleans stale Feishu p2p binding but keeps valid commands from auto-creating a group", async () => {
+    const platform = mockPlatform("feishu");
+    await recordSessionRegistry({
+      chatId: "feishu-p2p",
+      sessionId: "stale-sid",
+      tool: "claude",
+      chatName: "旧私聊绑定",
+      running: false,
+    });
+
+    await handleCommand(platform, "/model", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    expect(platform.createGroup).not.toHaveBeenCalled();
+    expect(platform.sendRawCard).toHaveBeenCalled();
+    const registry = await loadSessionRegistryForBinding();
+    expect(registry["feishu-p2p"]).toBeUndefined();
+  });
 });

package/src/__tests__/session.test.ts

@@ -160,7 +160,7 @@ function mockSessionInfo(chatId: string, overrides: Partial<{
 
 /**
  * 简易 mock adapter：getSessionInfo 返回固定 SessionInfo，其他方法不实现
- * （仅 /status、/sessions 路径会触发 getSessionInfo，无需完整接口）。
+ * （仅 /state、/sessions 路径会触发 getSessionInfo，无需完整接口）。
  */
 function mockAdapter(getInfo: (sid: string) => SessionInfo | undefined): ToolAdapter {
   return {
@@ -597,7 +597,7 @@ describe("getSessionStatus", () => {
   });
 
   // -------------------------------------------------------------------------
-  // model/effort 来源：按 tool 分支（核心契约——决定 /status 显示是否真实）
+  // model/effort 来源：按 tool 分支（核心契约——决定 /state 显示是否真实）
   // -------------------------------------------------------------------------
 
   it("Claude 会话：effort 非 null（始终显示该行）；model 来自全局配置", async () => {
@@ -643,7 +643,7 @@ describe("getSessionStatus", () => {
     expect(status!.model).toBe(UNKNOWN_MODEL_PLACEHOLDER);
   });
 
-  it("Cursor 会话：adapter.getSessionInfo 抛错时降级为占位符（不阻塞 /status）", async () => {
+  it("Cursor 会话：adapter.getSessionInfo 抛错时降级为占位符（不阻塞 /state）", async () => {
     mockSessionInfo("chat-cursor", { sessionId: "sid-cur", tool: "cursor" });
     _setAdapterForToolForTest(
       "cursor",

package/src/adapters/adapter-interface.ts

@@ -101,7 +101,7 @@ export interface CreateSessionResult {
 }
 
 // ---------------------------------------------------------------------------
-// SessionInfo — 会话元数据（/status、/cd 等命令使用）
+// SessionInfo — 会话元数据（/state、/cd 等命令使用）
 // ---------------------------------------------------------------------------
 
 export interface SessionInfo {
@@ -113,7 +113,7 @@ export interface SessionInfo {
    * 会话实际使用的模型展示名（如 Cursor 的 `Composer 2 Fast`）。
    * - Cursor adapter：从 cursor-agent system/init 事件学习并持久化到 store
    * - Claude adapter：留空（model 由 ChatCCC 配置 `CLAUDE_MODEL` 决定，不从 SDK 取）
-   * 上层 /status、/sessions 渲染时按 tool 决定显示哪一来源。
+   * 上层 /state、/sessions 渲染时按 tool 决定显示哪一来源。
    */
   model?: string;
 }

package/src/adapters/cursor-session-meta-store.ts

@@ -5,7 +5,7 @@
 // 内部已持久化）。Cursor CLI 没有等价机制，因此 ChatCCC 必须自己维护一份
 // sessionId → { cwd, model } 映射，否则：
 //   1. /git、/cd 等需要"会话真实工作目录"的命令将在 Cursor 会话上 100% 失败
-//   2. /status、/sessions 显示的"模型"只能硬塞 ChatCCC 的 ANTHROPIC 环境变量，
+//   2. /state、/sessions 显示的"模型"只能硬塞 ChatCCC 的 ANTHROPIC 环境变量，
 //      与 Cursor 实际跑的 Composer 2 Fast 等真实模型无关
 //
 // 存储：

package/src/cards.ts

@@ -89,7 +89,7 @@ export function buildProgressCard(
     elements.push({ tag: "hr" });
     elements.push({
       tag: "button",
-      text: { tag: "plain_text", content: "查看状态（/status）" },
+      text: { tag: "plain_text", content: "查看状态（/state）" },
       type: "default",
       value: { action: "status" },
       element_id: "action_status",

package/src/index.ts

@@ -109,6 +109,8 @@ import { createWechatAdapter, startWechatPlatform } from "./wechat-platform.ts";
 function createFeishuAdapter(): PlatformAdapter {
   const auth = () => getTenantAccessToken();
   return {
+    kind: "feishu",
+
     // ---- 基础消息 ----
     async sendText(chatId, text) {
       return sendTextReply(await auth(), chatId, text);
@@ -285,7 +287,7 @@ function parseCardAction(data: unknown): CardActionResult | null {
   }
   if (!cmd) return null;
 
-  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" };
+  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: "/state", 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;

package/src/orchestrator.ts

@@ -121,6 +121,43 @@ function shouldSendWechatProcessingAck(
   return platform.kind === "wechat" && chatType === "p2p" && !textLower.startsWith("/");
 }
 
+function isNonWechatP2p(platform: PlatformAdapter, chatType: string): boolean {
+  return chatType === "p2p" && platform.kind !== "wechat";
+}
+
+async function cleanupNonWechatP2pBinding(
+  platform: PlatformAdapter,
+  chatId: string,
+  chatType: string,
+  tid: string,
+): Promise<void> {
+  if (!isNonWechatP2p(platform, chatType)) return;
+
+  try {
+    const registry = await loadSessionRegistryForBinding();
+    const record = registry[chatId];
+    if (!record?.sessionId) return;
+
+    unbindChatFromSession(record.sessionId, chatId);
+    displayCards.delete(chatId);
+    cancelQueuedMessage(record.sessionId);
+    sessionInfoMap.delete(chatId);
+    await removeSessionRegistryRecord(chatId);
+    logTrace(tid, "BRANCH", {
+      reason: "cleanup_non_wechat_p2p_binding",
+      chatId,
+      oldSessionId: record.sessionId,
+    });
+    console.log(
+      `[${ts()}] [P2P] Removed non-WeChat p2p binding: chat=${chatId} session=${record.sessionId}`,
+    );
+  } catch (err) {
+    console.log(
+      `[${ts()}] [INFO] Cannot cleanup p2p registry for ${chatId}: ${(err as Error).message}`,
+    );
+  }
+}
+
 // ---------------------------------------------------------------------------
 // handleCommand — 平台无关的命令分发
 // ---------------------------------------------------------------------------
@@ -137,6 +174,7 @@ export async function handleCommand(
   const tid = traceId ?? makeTraceId();
   const textLower = text.toLowerCase();
   recordChatPlatform(chatId, platform);
+  await cleanupNonWechatP2pBinding(platform, chatId, chatType, tid);
 
   if (textLower === "/restart") {
     logTrace(tid, "BRANCH", { cmd: "/restart" });
@@ -523,8 +561,9 @@ export async function handleCommand(
         `[${ts()}] [INFO] Cannot get chat info for ${chatId}: ${(err as Error).message}`,
       );
     }
-  } else {
-    // 私聊：从 session-registry.json 获取绑定的 session
+  } else if (platform.kind === "wechat") {
+    // 微信私聊：从 session-registry.json 获取绑定的 session。
+    // 飞书私聊不再作为持久会话入口，避免历史 registry 残留误路由到旧 session。
     try {
       const registry = await loadSessionRegistryForBinding();
       const record = registry[chatId];
@@ -700,8 +739,8 @@ export async function handleCommand(
       return;
     }
 
-    if (textLower === "/status") {
-      logTrace(tid, "BRANCH", { cmd: "/status" });
+    if (textLower === "/state") {
+      logTrace(tid, "BRANCH", { cmd: "/state" });
       const status = await getSessionStatus(chatId);
       const isActive = isSessionRunning(sessionId);
       const statusText = [
@@ -1245,6 +1284,177 @@ export async function handleCommand(
     return;
   }
 
+  // 无会话上下文 → /sessions 仍是有效指令，不触发飞书私聊自动建群。
+  if (textLower === "/sessions") {
+    logTrace(tid, "BRANCH", { cmd: "/sessions", scope: "global" });
+    const allSessions = await getAllSessionsStatus();
+    const now = Date.now();
+    const cardData = allSessions.map((s) => ({
+      sessionId: s.sessionId,
+      chatName: s.chatName,
+      chatId: s.chatId,
+      active: s.active,
+      turnCount: s.turnCount,
+      elapsedSeconds: s.active
+        ? Math.floor((now - s.startTime) / 1000)
+        : null,
+      model: s.model,
+      tool: s.tool,
+    }));
+    const card = buildSessionsCard(cardData, { defaultToolLabel: toolDisplayName(resolveDefaultAgentTool()) });
+    const ok = await platform.sendRawCard(chatId, card);
+    console.log(
+      `[${ts()}] [SESSIONS] card sent, ok=${ok}, count=${cardData.length}`,
+    );
+    logTrace(tid, "DONE", { outcome: "sessions", ok, count: cardData.length });
+    return;
+  }
+
+  // 飞书私聊普通消息：不再绑定私聊本身，而是自动创建会话群并把私聊内容作为首轮 prompt。
+  if (isNonWechatP2p(platform, chatType) && !textLower.startsWith("/")) {
+    const tool = resolveDefaultAgentTool();
+    const toolLabel = toolDisplayName(tool);
+    logTrace(tid, "BRANCH", { cmd: "auto_new_from_p2p", tool });
+
+    if (!openId) {
+      logTrace(tid, "DONE", { outcome: "auto_new_p2p_no_openid" });
+      await platform.sendCard(
+        chatId,
+        "Error",
+        "Cannot identify sender.",
+        "red",
+      );
+      return;
+    }
+
+    let sessionId: string;
+    let sessionCwd: string;
+    try {
+      const init = await initClaudeSession(tool, undefined, chatId);
+      sessionId = init.sessionId;
+      sessionCwd = init.cwd;
+      console.log(
+        `[${ts()}] [AUTO-P2P 1/5] ${toolLabel} session created: ${sessionId} → OK`,
+      );
+    } catch (err) {
+      console.error(`[${ts()}] [AUTO-P2P 1/5] FAIL: ${(err as Error).message}`);
+      logTrace(tid, "DONE", {
+        outcome: "auto_new_p2p_session_fail",
+        error: (err as Error).message,
+      });
+      await platform.sendCard(
+        chatId,
+        "Error",
+        `Failed to initialize ${toolLabel} session:\n${(err as Error).message}`,
+        "red",
+      );
+      return;
+    }
+
+    const cwd = sessionCwd;
+    const initialName = sessionChatName(text.slice(0, 10) || "新会话", cwd);
+    let newChatId: string;
+    try {
+      newChatId = await platform.createGroup(initialName, [openId]);
+      console.log(
+        `[${ts()}] [AUTO-P2P 2/5] Created Feishu group: ${newChatId} → OK`,
+      );
+    } catch (err) {
+      console.error(`[${ts()}] [AUTO-P2P 2/5] FAIL: ${(err as Error).message}`);
+      logTrace(tid, "DONE", {
+        outcome: "auto_new_p2p_group_fail",
+        error: (err as Error).message,
+      });
+      await platform.sendCard(
+        chatId,
+        "Error",
+        `Failed to create group:\n${(err as Error).message}`,
+        "red",
+      );
+      return;
+    }
+
+    try {
+      const descPrefix = sessionPrefixForTool(tool);
+      await platform.updateChatInfo(
+        newChatId,
+        initialName,
+        `${descPrefix} ${sessionId}`,
+      );
+      console.log(
+        `[${ts()}] [AUTO-P2P 3/5] Renamed group → name="${initialName}" (${toolLabel}) → OK`,
+      );
+    } catch (err) {
+      console.error(`[${ts()}] [AUTO-P2P 3/5] FAIL: ${(err as Error).message}`);
+      logTrace(tid, "DONE", {
+        outcome: "auto_new_p2p_rename_fail",
+        error: (err as Error).message,
+      });
+      await platform.sendCard(
+        chatId,
+        "Error",
+        `Group created but rename failed:\n${(err as Error).message}`,
+        "yellow",
+      );
+      return;
+    }
+
+    await setDefaultCwd(cwd, newChatId);
+    bindChatToSession(sessionId, newChatId);
+    await recordSessionRegistry({
+      chatId: newChatId,
+      sessionId,
+      tool,
+      chatName: initialName,
+      turnCount: 0,
+      startTime: Date.now(),
+      running: false,
+    });
+    await saveSessionTool(sessionId, tool, initialName);
+
+    await platform.sendCard(
+      newChatId,
+      `${toolLabel} Session Ready`,
+      `已根据私聊消息创建 **${toolLabel}** 会话群。\n\n` +
+        `**Session ID:** ${sessionId}\n` +
+        `**工作目录:** \`${cwd}\`\n\n` +
+        `下面会自动把你的私聊消息作为第一句话发送给 ${toolLabel}。\n\n` +
+        `发送 **/model** 查看或切换当前会话的模型。\n` +
+        `发送 **/new** 创建新会话，**/newh** 重置当前会话（沿用工作目录）。`,
+      "green",
+    );
+    platform.setChatAvatar(newChatId, tool, "new").catch(() => {});
+    console.log(`[${ts()}] [AUTO-P2P 4/5] Replied to new group → OK`);
+
+    try {
+      logTrace(tid, "RESUME", { sessionId, tool, trigger: "auto_new_from_p2p" });
+      await resumeAndPrompt(
+        sessionId,
+        text,
+        platform,
+        newChatId,
+        msgTimestamp,
+        tool,
+        tid,
+      );
+      console.log(`[${ts()}] [AUTO-P2P 5/5] First prompt sent → OK`);
+      logTrace(tid, "DONE", { outcome: "auto_new_p2p_prompt_done", newChatId, sessionId, tool });
+    } catch (err) {
+      console.error(`[${ts()}] [AUTO-P2P 5/5] FAIL: ${(err as Error).message}`);
+      logTrace(tid, "DONE", {
+        outcome: "auto_new_p2p_prompt_fail",
+        error: (err as Error).message,
+      });
+      await platform.sendCard(
+        newChatId,
+        "Error",
+        `Failed to send first prompt:\n${(err as Error).message}`,
+        "red",
+      );
+    }
+    return;
+  }
+
   // 无会话上下文 → help card
   logTrace(tid, "SEND", { method: "help_card", chatId });
   const card = buildHelpCard(text, { defaultToolLabel: toolDisplayName(resolveDefaultAgentTool()) });

package/src/session.ts

@@ -1549,7 +1549,7 @@ export function stopSession(sessionId: string): boolean {
 }
 
 // ---------------------------------------------------------------------------
-// Session status query (供 /status、/sessions 命令使用)
+// Session status query (供 /state、/sessions 命令使用)
 // ---------------------------------------------------------------------------
 //
 // model / effort 的来源策略（按 tool 区分，避免硬塞 ChatCCC 全局配置导致显示
@@ -1590,7 +1590,7 @@ async function resolveModelEffort(
       const info = await adapter.getSessionInfo(sessionId);
       if (info?.model) model = info.model;
     } catch {
-      // adapter 异常时降级为占位符（不阻塞 /status 卡片）
+      // adapter 异常时降级为占位符（不阻塞 /state 卡片）
     }
     return { model, effort: null };
   }