chatccc 0.2.118 → 0.2.120

package/README.md

@@ -313,8 +313,8 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | `/model clear` | 清除模型覆盖，恢复默认 | 全部 |
 | `/cd` | 查看当前工作目录（含最近目录快捷按钮） | 全部 |
 | `/cd <路径>` | 设置新建会话的默认工作目录 | 全部 |
-| `/plan <消息>` | 以只读/规划模式提问，不修改文件 | Claude Code |
-| `/ask <消息>` | 以只读/问答模式提问，不修改文件 | Cursor |
+| `/plan <消息>` | Claude Code 使用 CLI 只读/规划模式；其他 Agent 会收到包含 `/plan` 前缀的原始消息，可能通过消息内容自行支持 | Claude Code（CLI 模式）/ 全部（消息透传） |
+| `/ask <消息>` | Cursor 使用 CLI 只读/问答模式；其他 Agent 会收到包含 `/ask` 前缀的原始消息，可能通过消息内容自行支持 | Cursor（CLI 模式）/ 全部（消息透传） |
 | `/git <子命令>` | 在当前会话工作目录执行 git 命令并回传输出 | 全部 |
 | `/deleteg` | 解散当前群聊，保留 Agent 会话 | 全部（仅群聊） |
 | `/restart` | 重启 ChatCCC 服务进程 | 全部 |

package/package.json

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

package/src/__tests__/orchestrator.test.ts

@@ -154,25 +154,67 @@ describe("handleCommand WeChat processing ack", () => {
     expect(platform.sendCard).not.toHaveBeenCalled();
   });
 
-  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",
+  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", "生成中...");
-  });
-
-  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 {
+
+    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
+  });
+
+  it.each([
+    { tool: "claude" as const, sessionId: "sid-claude", text: "/ask 只回答不要改文件" },
+    { tool: "cursor" as const, sessionId: "sid-cursor", text: "/plan 先给我计划" },
+  ])("passes unsupported mode commands through as raw prompts for $tool", async ({ tool, sessionId, text }) => {
+    const platform = mockPlatform();
+    const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
+      yield {
+        type: "assistant" as const,
+        blocks: [{ type: "text" as const, text: `收到: ${userText}` }],
+      };
+    });
+    _setAdapterForToolForTest(tool, {
+      displayName: tool,
+      sessionDescPrefix: `${tool} Session:`,
+      createSession: vi.fn(async () => ({ sessionId })),
+      prompt,
+      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
+        sessionId,
+        cwd: "F:\\repo",
+      }),
+      closeSession: async () => {},
+    });
+    await recordSessionRegistry({
+      chatId: "wx-chat",
+      sessionId,
+      tool,
+      chatName: "ready-session",
+      running: false,
+    });
+
+    await handleCommand(platform, text, "wx-chat", "wx-user", Date.now(), "p2p");
+
+    expect(platform.sendText).not.toHaveBeenCalledWith("wx-chat", expect.stringContaining("仅在以下 Agent 会话中可用"));
+    expect(prompt).toHaveBeenCalledWith(
+      sessionId,
+      expect.stringContaining(text),
+      "F:\\repo",
+      expect.any(AbortSignal),
+      expect.objectContaining({ permissionMode: undefined }),
+    );
+  });
+
+  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}` }],
       };

package/src/adapters/claude-adapter.ts

@@ -276,14 +276,15 @@ function buildCliArgs(
   extraArgs: string[],
   permissionMode?: "plan" | "ask",
 ): string[] {
-  const permMode = permissionMode === "plan" ? "plan" : "bypassPermissions";
+  const permMode = permissionMode === "plan" ? "plan" : permissionMode === "ask" ? "default" : "bypassPermissions";
+  const skipPermissions = permissionMode !== "plan" && permissionMode !== "ask";
   const args = [
     "-p",
     "--output-format", "stream-json",
     "--verbose",
     "--setting-sources", "user,project,local",
     "--permission-mode", permMode,
-    "--dangerously-skip-permissions",
+    ...(skipPermissions ? ["--dangerously-skip-permissions"] : []),
     "--settings", "{\"maxTurns\":0}",
   ];
 

package/src/orchestrator.ts

@@ -158,6 +158,54 @@ function resolveModeCommand(cmd: string): { mode: "plan" | "ask"; supportedTools
   return mode ? { mode, supportedTools } : null;
 }
 
+/** 如果当前群名是未命名会话（"新会话" 或 "新会话-xxx"），用消息内容前缀重命名 */
+async function renameUntitledSession(
+  platform: PlatformAdapter,
+  chatId: string,
+  chatType: string,
+  sessionId: string,
+  tool: string,
+  namePrefix: string,
+  description: string | undefined,
+  chatInfo: { name: string } | undefined,
+): Promise<void> {
+  const MAX_PREFIX = 10;
+  const prefix = namePrefix.slice(0, MAX_PREFIX);
+
+  if (chatType !== "p2p" && chatInfo && isUntitledSessionChatName(chatInfo.name)) {
+    const adapter = getAdapterForTool(tool, sessionId);
+    const info = await adapter.getSessionInfo(sessionId).catch(() => undefined);
+    const sessionCwd = info?.cwd ?? (await getDefaultCwd(chatId));
+    const newName = sessionChatName(prefix, sessionCwd);
+    try {
+      await platform.updateChatInfo(chatId, newName, description!);
+      console.log(`[${ts()}] [RENAME] First message → group renamed to "${newName}"`);
+      await recordSessionRegistry({ chatId, sessionId, tool, chatName: newName }).catch(() => {});
+      await saveSessionTool(sessionId, tool, newName).catch(() => {});
+    } catch (err) {
+      console.error(`[${ts()}] [RENAME] Failed: ${(err as Error).message}`);
+    }
+  }
+
+  if (chatType === "p2p" && platform.kind === "wechat") {
+    try {
+      const reg = await loadSessionRegistryForBinding();
+      const rec = reg[chatId];
+      if (rec && rec.sessionId === sessionId && isUntitledSessionChatName(rec.chatName ?? "")) {
+        const adapter = getAdapterForTool(tool, sessionId);
+        const info = await adapter.getSessionInfo(sessionId).catch(() => undefined);
+        const sessionCwd = info?.cwd ?? (await getDefaultCwd(chatId));
+        const newName2 = sessionChatName(prefix, sessionCwd);
+        await recordSessionRegistry({ chatId, sessionId, tool, chatName: newName2 }).catch(() => {});
+        await saveSessionTool(sessionId, tool, newName2).catch(() => {});
+        console.log(`[${ts()}] [RENAME] WeChat P2P → "${newName2}"`);
+      }
+    } catch (err) {
+      console.error(`[${ts()}] [RENAME] WeChat P2P failed: ${(err as Error).message}`);
+    }
+  }
+}
+
 async function cleanupNonWechatP2pBinding(
   platform: PlatformAdapter,
   chatId: string,
@@ -1206,126 +1254,132 @@ export async function handleCommand(
     }
 
     // /plan <message> — 只读/规划模式
-    if (textLower.startsWith("/plan ")) {
-      const planText = text.slice(6).trim();
-      const resolved = resolveModeCommand("/plan");
-      if (!planText) {
-        await platform.sendText(chatId, "用法：`/plan <消息>` — 在只读/规划模式下提问。").catch(() => {});
-        logTrace(tid, "DONE", { outcome: "plan_no_message" });
-        return;
-      }
-      if (!resolved || !resolved.supportedTools.includes(descriptionTool)) {
-        const supported = resolved?.supportedTools.map(t => toolDisplayName(t)).join("、") ?? "(无)";
-        await platform.sendText(chatId, `/plan 仅在以下 Agent 会话中可用：${supported}。`).catch(() => {});
-        logTrace(tid, "DONE", { outcome: "plan_wrong_tool", tool: descriptionTool });
-        return;
-      }
-      logTrace(tid, "BRANCH", { cmd: "/plan", sessionId, tool: descriptionTool });
-
-      if (isSessionRunning(sessionId)) {
-        const queued = enqueueMessage(sessionId, {
-          text, chatId, openId, msgTimestamp, chatType, traceId: tid,
-        });
-        if (queued) {
-          logTrace(tid, "QUEUED", { sessionId, mode: "plan" });
-          if (platform.kind === "wechat") {
-            await platform.sendText(chatId, "当前会话正在生成中，你的消息已进入缓存队列，生成完成后会立即处理。发送 /cancel 可取消缓存。").catch(() => {});
-          } else {
-            await platform.sendRawCard(chatId, buildQueuedCard(planText)).catch(() => {});
-          }
-        } else {
-          logTrace(tid, "QUEUE_FULL", { sessionId });
-          if (platform.kind === "wechat") {
-            await platform.sendText(chatId, "当前缓存队列中已有消息等待处理，请等待或发送 /stop（停止生成）或 /cancel（取消缓存）。").catch(() => {});
-          } else {
-            await platform.sendRawCard(chatId, buildQueueFullCard()).catch(() => {});
-          }
-        }
-        return;
-      }
-
-      if (shouldSendWechatProcessingAck(platform, planText.toLowerCase(), chatType)) {
-        await platform.sendText(chatId, "生成中...").catch(() => {});
-      }
-
-      try {
-        logTrace(tid, "RESUME", { sessionId, tool: descriptionTool, mode: "plan" });
-        await resumeAndPrompt(
-          sessionId, planText, platform, chatId, msgTimestamp,
-          descriptionTool, tid, "plan",
-        );
-        logTrace(tid, "DONE", { outcome: "plan_done", sessionId });
-      } catch (err) {
-        logTrace(tid, "DONE", { outcome: "plan_fail", error: (err as Error).message });
-        await platform.sendCard(
-          chatId, "Error",
-          `Failed to run plan mode:\n${(err as Error).message}`,
-          "red",
-        );
-      }
-      return;
-    }
+    if (textLower.startsWith("/plan ")) {
+      const planText = text.slice(6).trim();
+      const resolved = resolveModeCommand("/plan");
+      if (!planText) {
+        await platform.sendText(chatId, "用法：`/plan <消息>` — 在只读/规划模式下提问。").catch(() => {});
+        logTrace(tid, "DONE", { outcome: "plan_no_message" });
+        return;
+      }
+      if (resolved?.supportedTools.includes(descriptionTool) === true) {
+        logTrace(tid, "BRANCH", { cmd: "/plan", sessionId, tool: descriptionTool });
+
+        await renameUntitledSession(
+          platform, chatId, chatType, sessionId, descriptionTool,
+          planText, description, chatInfo,
+        );
+
+        if (isSessionRunning(sessionId)) {
+          const queued = enqueueMessage(sessionId, {
+            text, chatId, openId, msgTimestamp, chatType, traceId: tid,
+          });
+          if (queued) {
+            logTrace(tid, "QUEUED", { sessionId, mode: "plan" });
+            if (platform.kind === "wechat") {
+              await platform.sendText(chatId, "当前会话正在生成中，你的消息已进入缓存队列，生成完成后会立即处理。发送 /cancel 可取消缓存。").catch(() => {});
+            } else {
+              await platform.sendRawCard(chatId, buildQueuedCard(planText)).catch(() => {});
+            }
+          } else {
+            logTrace(tid, "QUEUE_FULL", { sessionId });
+            if (platform.kind === "wechat") {
+              await platform.sendText(chatId, "当前缓存队列中已有消息等待处理，请等待或发送 /stop（停止生成）或 /cancel（取消缓存）。").catch(() => {});
+            } else {
+              await platform.sendRawCard(chatId, buildQueueFullCard()).catch(() => {});
+            }
+          }
+          return;
+        }
+
+        if (shouldSendWechatProcessingAck(platform, planText.toLowerCase(), chatType)) {
+          await platform.sendText(chatId, "生成中...").catch(() => {});
+        }
+
+        try {
+          logTrace(tid, "RESUME", { sessionId, tool: descriptionTool, mode: "plan" });
+          await resumeAndPrompt(
+            sessionId, planText, platform, chatId, msgTimestamp,
+            descriptionTool, tid, "plan",
+          );
+          logTrace(tid, "DONE", { outcome: "plan_done", sessionId });
+        } catch (err) {
+          logTrace(tid, "DONE", { outcome: "plan_fail", error: (err as Error).message });
+          await platform.sendCard(
+            chatId, "Error",
+            `Failed to run plan mode:\n${(err as Error).message}`,
+            "red",
+          );
+        }
+        return;
+      }
+
+      logTrace(tid, "BRANCH", { cmd: "/plan", sessionId, tool: descriptionTool, fallback: "raw_message" });
+    }
 
     // /ask <message> — 只读/问答模式
-    if (textLower.startsWith("/ask ")) {
-      const askText = text.slice(5).trim();
-      const resolved = resolveModeCommand("/ask");
-      if (!askText) {
-        await platform.sendText(chatId, "用法：`/ask <消息>` — 在只读/问答模式下提问。").catch(() => {});
-        logTrace(tid, "DONE", { outcome: "ask_no_message" });
-        return;
-      }
-      if (!resolved || !resolved.supportedTools.includes(descriptionTool)) {
-        const supported = resolved?.supportedTools.map(t => toolDisplayName(t)).join("、") ?? "(无)";
-        await platform.sendText(chatId, `/ask 仅在以下 Agent 会话中可用：${supported}。`).catch(() => {});
-        logTrace(tid, "DONE", { outcome: "ask_wrong_tool", tool: descriptionTool });
-        return;
-      }
-      logTrace(tid, "BRANCH", { cmd: "/ask", sessionId, tool: descriptionTool });
-
-      if (isSessionRunning(sessionId)) {
-        const queued = enqueueMessage(sessionId, {
-          text, chatId, openId, msgTimestamp, chatType, traceId: tid,
-        });
-        if (queued) {
-          logTrace(tid, "QUEUED", { sessionId, mode: "ask" });
-          if (platform.kind === "wechat") {
-            await platform.sendText(chatId, "当前会话正在生成中，你的消息已进入缓存队列，生成完成后会立即处理。发送 /cancel 可取消缓存。").catch(() => {});
-          } else {
-            await platform.sendRawCard(chatId, buildQueuedCard(askText)).catch(() => {});
-          }
-        } else {
-          logTrace(tid, "QUEUE_FULL", { sessionId });
-          if (platform.kind === "wechat") {
-            await platform.sendText(chatId, "当前缓存队列中已有消息等待处理，请等待或发送 /stop（停止生成）或 /cancel（取消缓存）。").catch(() => {});
-          } else {
-            await platform.sendRawCard(chatId, buildQueueFullCard()).catch(() => {});
-          }
-        }
-        return;
-      }
-
-      if (shouldSendWechatProcessingAck(platform, askText.toLowerCase(), chatType)) {
-        await platform.sendText(chatId, "生成中...").catch(() => {});
-      }
-
-      try {
-        logTrace(tid, "RESUME", { sessionId, tool: descriptionTool, mode: "ask" });
-        await resumeAndPrompt(
-          sessionId, askText, platform, chatId, msgTimestamp,
-          descriptionTool, tid, "ask",
-        );
-        logTrace(tid, "DONE", { outcome: "ask_done", sessionId });
-      } catch (err) {
-        logTrace(tid, "DONE", { outcome: "ask_fail", error: (err as Error).message });
-        await platform.sendCard(
-          chatId, "Error",
-          `Failed to run ask mode:\n${(err as Error).message}`,
-          "red",
-        );
-      }
-      return;
-    }
+    if (textLower.startsWith("/ask ")) {
+      const askText = text.slice(5).trim();
+      const resolved = resolveModeCommand("/ask");
+      if (!askText) {
+        await platform.sendText(chatId, "用法：`/ask <消息>` — 在只读/问答模式下提问。").catch(() => {});
+        logTrace(tid, "DONE", { outcome: "ask_no_message" });
+        return;
+      }
+      if (resolved?.supportedTools.includes(descriptionTool) === true) {
+        logTrace(tid, "BRANCH", { cmd: "/ask", sessionId, tool: descriptionTool });
+
+        await renameUntitledSession(
+          platform, chatId, chatType, sessionId, descriptionTool,
+          askText, description, chatInfo,
+        );
+
+        if (isSessionRunning(sessionId)) {
+          const queued = enqueueMessage(sessionId, {
+            text, chatId, openId, msgTimestamp, chatType, traceId: tid,
+          });
+          if (queued) {
+            logTrace(tid, "QUEUED", { sessionId, mode: "ask" });
+            if (platform.kind === "wechat") {
+              await platform.sendText(chatId, "当前会话正在生成中，你的消息已进入缓存队列，生成完成后会立即处理。发送 /cancel 可取消缓存。").catch(() => {});
+            } else {
+              await platform.sendRawCard(chatId, buildQueuedCard(askText)).catch(() => {});
+            }
+          } else {
+            logTrace(tid, "QUEUE_FULL", { sessionId });
+            if (platform.kind === "wechat") {
+              await platform.sendText(chatId, "当前缓存队列中已有消息等待处理，请等待或发送 /stop（停止生成）或 /cancel（取消缓存）。").catch(() => {});
+            } else {
+              await platform.sendRawCard(chatId, buildQueueFullCard()).catch(() => {});
+            }
+          }
+          return;
+        }
+
+        if (shouldSendWechatProcessingAck(platform, askText.toLowerCase(), chatType)) {
+          await platform.sendText(chatId, "生成中...").catch(() => {});
+        }
+
+        try {
+          logTrace(tid, "RESUME", { sessionId, tool: descriptionTool, mode: "ask" });
+          await resumeAndPrompt(
+            sessionId, askText, platform, chatId, msgTimestamp,
+            descriptionTool, tid, "ask",
+          );
+          logTrace(tid, "DONE", { outcome: "ask_done", sessionId });
+        } catch (err) {
+          logTrace(tid, "DONE", { outcome: "ask_fail", error: (err as Error).message });
+          await platform.sendCard(
+            chatId, "Error",
+            `Failed to run ask mode:\n${(err as Error).message}`,
+            "red",
+          );
+        }
+        return;
+      }
+
+      logTrace(tid, "BRANCH", { cmd: "/ask", sessionId, tool: descriptionTool, fallback: "raw_message" });
+    }
 
     const lastTs = lastMsgTimestamps.get(chatId);
     if (lastTs !== undefined && msgTimestamp <= lastTs) {