chatccc 0.2.117 → 0.2.119

package/src/adapters/cursor-adapter.ts

@@ -261,8 +261,18 @@ function spawnAgent(
   cwd?: string,
   stdinText?: string,
   modelOverride?: string,
+  permissionMode?: "plan" | "ask",
 ): ChildProcess {
   let allArgs = [...CURSOR_AGENT_ARGS, ...extraArgs];
+  if (permissionMode === "ask") {
+    // 替换已有的 --mode 或追加
+    const modeIdx = allArgs.findIndex((a, i) => a === "--mode" && i + 1 < allArgs.length);
+    if (modeIdx >= 0) {
+      allArgs[modeIdx + 1] = "ask";
+    } else {
+      allArgs.push("--mode", "ask");
+    }
+  }
   if (modelOverride) {
     // 替换全局 --model 为 per-session override
     const modelIdx = allArgs.findIndex((a, i) => a === "--model" && i + 1 < allArgs.length);
@@ -370,7 +380,7 @@ class CursorAdapter implements ToolAdapter {
     options?: ToolPromptOptions,
   ): AsyncIterable<UnifiedStreamMessage> {
     console.log(`[Cursor debug] prompt start: sessionId=${sessionId}, cwd=${cwd}, userTextLen=${userText.length}`);
-    const proc = spawnAgent(["--resume", sessionId], cwd, userText, this.modelOverride);
+    const proc = spawnAgent(["--resume", sessionId], cwd, userText, this.modelOverride, options?.permissionMode);
     this.activeProcs.add(proc);
     if (proc.pid !== undefined) options?.onProcessStart?.({ pid: proc.pid });
 

package/src/cards.ts

@@ -131,6 +131,8 @@ export function buildHelpCard(
     "发送 **/new cursor** 创建新 Cursor 会话",
     "发送 **/new codex** 创建新 Codex 会话",
     "发送 **/newh** 重置当前会话（沿用当前工作目录，不切换）",
+    "发送 **/plan <消息>** 在 Claude 会话中以只读规划模式提问",
+    "发送 **/ask <消息>** 在 Cursor 会话中以只读问答模式提问",
   ].join("\n");
   return JSON.stringify({
     config: { wide_screen_mode: true },

package/src/config.ts

@@ -122,6 +122,24 @@ export interface AppConfig {
 export type AgentTool = "claude" | "cursor" | "codex";
 export const AGENT_TOOLS: AgentTool[] = ["claude", "cursor", "codex"];
 
+/**
+ * Agent 专属模式指令（内部配置，非用户可配）。
+ * 映射每个 Agent 支持的特殊指令及其对应的 CLI 权限模式。
+ *
+ * - claude: /plan → --permission-mode plan（只读/规划）
+ * - cursor: /ask  → --mode ask（只读/问答）
+ * - codex:  暂无原生只读模式，不注册任何模式指令
+ */
+export const AGENT_MODE_COMMANDS: Record<AgentTool, { command: string; mode: "plan" | "ask"; description: string }[]> = {
+  claude: [
+    { command: "/plan", mode: "plan", description: "以只读规划模式提问（Claude 专属）" },
+  ],
+  cursor: [
+    { command: "/ask", mode: "ask", description: "以只读问答模式提问（Cursor 专属）" },
+  ],
+  codex: [],
+};
+
 /** 获取指定 agent 配置中所有模型相关的值（最多 100 个，去重） */
 export function getAllModelsForTool(tool: AgentTool, cfg: AppConfig = config): string[] {
   const seen = new Set<string>();

package/src/orchestrator.ts

@@ -19,6 +19,8 @@ import {
   CONFIG_FILE,
   GIT_TIMEOUT_MS,
   PROJECT_ROOT,
+  AGENT_MODE_COMMANDS,
+  AGENT_TOOLS,
   anthropicConfigDisplay,
   config,
   fileLog,
@@ -125,6 +127,85 @@ function isNonWechatP2p(platform: PlatformAdapter, chatType: string): boolean {
   return chatType === "p2p" && platform.kind !== "wechat";
 }
 
+/** 根据 Agent 类型构建欢迎卡片中的指令说明 */
+function buildWelcomeCommands(tool: string): string {
+  const lines = [
+    "发送 **/cd** 切换新建会话的默认目录。",
+    "发送 **/model** 查看或切换当前会话的模型。",
+    "发送 **/new** 创建新会话，**/newh** 重置当前会话（沿用工作目录）。",
+    "发送 **/sessions** 查看所有会话状态。",
+  ];
+  const modeCmds = AGENT_MODE_COMMANDS[tool as AgentTool] ?? [];
+  for (const mc of modeCmds) {
+    lines.push(`发送 **${mc.command} <消息>** ${mc.description}。`);
+  }
+  return lines.join("\n");
+}
+
+/** 根据指令名从 AGENT_MODE_COMMANDS 查找对应的 mode 和支持的 agent 列表 */
+function resolveModeCommand(cmd: string): { mode: "plan" | "ask"; supportedTools: string[] } | null {
+  const supportedTools: string[] = [];
+  let mode: "plan" | "ask" | null = null;
+  for (const tool of AGENT_TOOLS) {
+    for (const mc of AGENT_MODE_COMMANDS[tool]) {
+      if (mc.command === cmd) {
+        supportedTools.push(tool);
+        mode = mc.mode;
+        break;
+      }
+    }
+  }
+  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,
@@ -429,11 +510,7 @@ export async function handleCommand(
           `**Session ID:** ${sessionId}\n` +
           `**工作目录:** \`${cwd}\`\n\n` +
           `直接在这里发消息即可与 ${toolLabel} 对话。\n\n` +
-          `发送 **/cd** 切换新建会话的默认目录。\n` +
-          `发送 **/model** 查看或切换当前会话的模型。\n` +
-          `发送 **/new** 创建新会话，**/newh** 重置当前会话（沿用工作目录）。\n` +
-          `发送 **/sessions** 查看所有会话状态。\n` +
-          `发送 \`/git <子命令>\` 在本会话工作目录执行 git，例如 \`/git status\`、\`/git log --oneline -n 5\`。`,
+          buildWelcomeCommands(tool),
         "green",
       );
       console.log(
@@ -515,11 +592,7 @@ export async function handleCommand(
         `**Session ID:** ${sessionId}\n` +
         `**工作目录:** \`${cwd}\`\n\n` +
         `直接在这里发消息即可与 ${toolLabel} 对话。\n\n` +
-        `发送 **/cd** 切换新建会话的默认目录。\n` +
-        `发送 **/model** 查看或切换当前会话的模型。\n` +
-        `发送 **/new** 创建新会话，**/newh** 重置当前会话（沿用工作目录）。\n` +
-        `发送 **/sessions** 查看所有会话状态。\n` +
-        `发送 \`/git <子命令>\` 在本会话工作目录执行 git，例如 \`/git status\`、\`/git log --oneline -n 5\`。`,
+        buildWelcomeCommands(tool),
       "green",
     );
 
@@ -877,9 +950,8 @@ export async function handleCommand(
         `会话已重置为新的 **${toolLabel}** 会话。\n\n` +
           `**Session ID:** ${newSessionId}\n` +
           `**工作目录:** \`${cwd}\`（沿用当前会话目录）\n\n` +
-          `直接在这里发消息即可继续对话。\n` +
-          `发送 **/cd** 可切换新建会话的默认目录。\n` +
-          `发送 **/model** 查看或切换当前会话的模型。`,
+          `直接在这里发消息即可继续对话。\n\n` +
+          buildWelcomeCommands(descriptionTool),
         "green",
       );
 
@@ -1181,6 +1253,134 @@ export async function handleCommand(
       return;
     }
 
+    // /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?.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?.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) {
       logTrace(tid, "DONE", {
@@ -1419,8 +1619,7 @@ export async function handleCommand(
         `**Session ID:** ${sessionId}\n` +
         `**工作目录:** \`${cwd}\`\n\n` +
         `下面会自动把你的私聊消息作为第一句话发送给 ${toolLabel}。\n\n` +
-        `发送 **/model** 查看或切换当前会话的模型。\n` +
-        `发送 **/new** 创建新会话，**/newh** 重置当前会话（沿用工作目录）。`,
+        buildWelcomeCommands(tool),
       "green",
     );
     platform.setChatAvatar(newChatId, tool, "new").catch(() => {});

package/src/session.ts

@@ -832,8 +832,9 @@ export async function resumeAndPrompt(
   msgTimestamp: number,
   tool: string,
   traceId?: string,
+  permissionMode?: "plan" | "ask",
 ): Promise<void> {
-  return runAgentSession(sessionId, userText, platform, chatId, msgTimestamp, tool, traceId);
+  return runAgentSession(sessionId, userText, platform, chatId, msgTimestamp, tool, traceId, permissionMode);
 }
 
 // ---------------------------------------------------------------------------
@@ -848,6 +849,7 @@ export async function runAgentSession(
   msgTimestamp: number,
   tool: string,
   traceId?: string,
+  permissionMode?: "plan" | "ask",
 ): Promise<void> {
   const tid = traceId ?? "";
 
@@ -1106,6 +1108,7 @@ export async function runAgentSession(
         clearPromptProcessMonitor(sessionId);
         if (exitInfo.pid !== undefined) unregisterProcess(exitInfo.pid);
       },
+      permissionMode,
     })) {
       for (const block of unifiedMsg.blocks) {
         accumulateBlockContent(block, state, toolCallMap);