@wu529778790/open-im 1.0.2-beta.3 → 1.0.2

package/README.md

@@ -87,8 +87,16 @@ open-im run
 
 1. 在 [飞书开放平台](https://open.feishu.cn/) 创建企业自建应用
 2. 开启「机器人」能力
-3. 配置事件订阅：启用 `im.message.receive_v1`，使用 **长连接** 模式（WebSocket）
-4. 将机器人添加到目标群聊或发起私聊
+3. 配置事件订阅：启用 `im.message.receive_v1`（接收消息），使用 **长连接** 模式（WebSocket）
+4. **卡片按钮（/mode、权限允许/拒绝）需额外配置回调**：
+   - 打开 [开放平台](https://open.feishu.cn/app) → 进入你的应用 → **「事件与回调」**
+   - 注意：页面有 **「事件」** 和 **「回调」** 两个 Tab，卡片在 **「回调」** 里，不在「事件」里
+   - 切换到 **「回调」** Tab → 选择 **「使用长连接接收回调」**
+   - 点击 **「添加回调」**（或类似按钮）→ 在列表中找到 **「卡片回传交互」**（`card.action.trigger`）
+   - 若列表里搜不到，可尝试：切换分类、搜「action」或「trigger」、或直接浏览「消息与群组」相关分类
+5. 将机器人添加到目标群聊或发起私聊
+
+**若点击 /mode 卡片按钮报错**：说明未配置卡片回调。配置较复杂时，可直接用 `/mode ask`、`/mode yolo` 等命令切换模式，无需卡片。
 
 ## 开发
 
@@ -103,6 +111,8 @@ npm run foreground # 前台运行已构建版本
 | 命令 | 说明 |
 |------|------|
 | `/help` | 显示帮助 |
+| `/mode` | 切换权限模式（卡片/按钮选择） |
+| `/mode <模式>` | 直接切换：ask / accept-edits / plan / yolo |
 | `/new` | 开始新会话 |
 | `/status` | 显示状态（AI 工具、工作目录、费用等） |
 | `/cd <路径>` | 切换工作目录 |
@@ -110,6 +120,17 @@ npm run foreground # 前台运行已构建版本
 | `/allow` `/y` | 允许权限请求 |
 | `/deny` `/n` | 拒绝权限请求 |
 
+### 权限模式
+
+与 Claude Code 官方命名一致，见 [permissions](https://code.claude.com/docs/en/permissions)：
+
+| 模式 | Claude 名 | 说明 |
+|------|-----------|------|
+| ask | default | 首次使用每个工具时提示确认 |
+| accept-edits | acceptEdits | 编辑权限自动通过 |
+| plan | plan | 仅分析，不修改文件不执行命令 |
+| yolo | bypassPermissions | 跳过所有权限确认 |
+
 ## 📝 License
 
 [MIT](LICENSE)
@@ -214,3 +235,14 @@ npx @wu529778790/open-im run
 3. **用户 ID 白名单问题**
    - 检查配置文件中的 `allowedUserIds` 是否包含你的用户 ID
    - 或留空允许所有人访问（仅开发环境建议）
+
+### Q: 飞书 /mode 卡片点击报错（如 200340）？
+
+说明未配置**卡片回调**。注意：卡片在 **「回调」** Tab，不在「事件」Tab。
+
+1. 打开 [飞书开放平台](https://open.feishu.cn/app) → 进入你的应用 → **「事件与回调」**
+2. 切换到 **「回调」** Tab（不是「事件」）
+3. 选择 **「使用长连接接收回调」**
+4. 添加 **「卡片回传交互」**（`card.action.trigger`）— 若搜不到，可尝试搜「action」「trigger」或浏览分类
+
+**更简单**：直接用 `/mode ask`、`/mode yolo` 等命令切换模式，无需配置卡片。

package/dist/adapters/claude-adapter.js

@@ -17,6 +17,7 @@ export class ClaudeAdapter {
     run(prompt, sessionId, workDir, callbacks, options) {
         const opts = {
             skipPermissions: options?.skipPermissions,
+            permissionMode: options?.permissionMode,
             timeoutMs: options?.timeoutMs,
             model: options?.model,
             chatId: options?.chatId,

package/dist/adapters/tool-adapter.interface.d.ts

@@ -21,6 +21,8 @@ export interface RunCallbacks {
 }
 export interface RunOptions {
     skipPermissions?: boolean;
+    /** Claude --permission-mode: default | acceptEdits | plan（yolo 时用 skipPermissions） */
+    permissionMode?: 'default' | 'acceptEdits' | 'plan';
     timeoutMs?: number;
     model?: string;
     chatId?: string;

package/dist/claude/cli-runner.d.ts

@@ -17,6 +17,7 @@ export interface ClaudeRunCallbacks {
 }
 export interface ClaudeRunOptions {
     skipPermissions?: boolean;
+    permissionMode?: 'default' | 'acceptEdits' | 'plan';
     timeoutMs?: number;
     model?: string;
     chatId?: string;

package/dist/claude/cli-runner.js

@@ -12,8 +12,12 @@ export function runClaude(cliPath, prompt, sessionId, workDir, callbacks, option
         "--verbose",
         "--include-partial-messages",
     ];
-    if (options?.skipPermissions)
+    if (options?.skipPermissions) {
         args.push("--dangerously-skip-permissions");
+    }
+    else if (options?.permissionMode) {
+        args.push("--permission-mode", options.permissionMode);
+    }
     if (options?.model)
         args.push("--model", options.model);
     if (sessionId)

package/dist/claude/process-pool.d.ts

@@ -27,6 +27,7 @@ export interface ClaudeResult {
 }
 export interface ClaudeRunOptions {
     skipPermissions?: boolean;
+    permissionMode?: 'default' | 'acceptEdits' | 'plan';
     timeoutMs?: number;
     model?: string;
     chatId?: string;

package/dist/claude/process-pool.js

@@ -62,8 +62,12 @@ export class ClaudeProcessPool {
                 "--verbose",
                 "--include-partial-messages",
             ];
-            if (options.skipPermissions)
+            if (options.skipPermissions) {
                 args.push("--dangerously-skip-permissions");
+            }
+            else if (options.permissionMode) {
+                args.push("--permission-mode", options.permissionMode);
+            }
             if (options.model)
                 args.push("--model", options.model);
             if (sessionId)

package/dist/commands/handler.d.ts

@@ -1,11 +1,14 @@
 import type { Config } from '../config.js';
 import type { SessionManager } from '../session/session-manager.js';
 import type { RequestQueue } from '../queue/request-queue.js';
+import { type PermissionMode } from '../permission-mode/types.js';
 import type { ThreadContext } from '../shared/types.js';
 export type { ThreadContext };
 export interface MessageSender {
     sendTextReply(chatId: string, text: string, threadCtx?: ThreadContext): Promise<void>;
     sendDirectorySelection?(chatId: string, currentDir: string, userId: string): Promise<void>;
+    sendModeCard?(chatId: string, userId: string, currentMode: PermissionMode): Promise<void>;
+    sendModeKeyboard?(chatId: string, userId: string, currentMode: PermissionMode): Promise<void>;
 }
 export interface CommandHandlerDeps {
     config: Config;
@@ -19,6 +22,8 @@ export declare class CommandHandler {
     private deps;
     constructor(deps: CommandHandlerDeps);
     dispatch(text: string, chatId: string, userId: string, platform: 'feishu' | 'telegram', handleClaudeRequest: ClaudeRequestHandler): Promise<boolean>;
+    private handleMode;
+    private getClearHistoryHint;
     private handleHelp;
     private handleNew;
     private handlePwd;

package/dist/commands/handler.js

@@ -1,4 +1,6 @@
 import { resolveLatestPermission, getPendingCount } from '../hook/permission-server.js';
+import { getPermissionMode, setPermissionMode } from '../permission-mode/session-mode.js';
+import { MODE_LABELS, MODE_DESCRIPTIONS, parsePermissionMode } from '../permission-mode/types.js';
 import { TERMINAL_ONLY_COMMANDS } from '../constants.js';
 import { execFile } from 'node:child_process';
 import { readdirSync } from 'node:fs';
@@ -16,8 +18,10 @@ export class CommandHandler {
         }
         if (t === '/help')
             return this.handleHelp(chatId, platform);
+        if (t === '/mode' || t.startsWith('/mode '))
+            return this.handleMode(chatId, userId, platform, t.slice(6).trim());
         if (t === '/new')
-            return this.handleNew(chatId, userId);
+            return this.handleNew(chatId, userId, platform);
         if (t === '/pwd')
             return this.handlePwd(chatId, userId);
         if (t === '/status')
@@ -27,7 +31,7 @@ export class CommandHandler {
         if (t === '/deny' || t === '/n')
             return this.handleDeny(chatId);
         if (t === '/cd' || t.startsWith('/cd ')) {
-            return this.handleCd(chatId, userId, t.slice(3).trim());
+            return this.handleCd(chatId, userId, t.slice(3).trim(), platform);
         }
         const cmd = t.split(/\s+/)[0];
         if (TERMINAL_ONLY_COMMANDS.has(cmd)) {
@@ -36,11 +40,46 @@ export class CommandHandler {
         }
         return false;
     }
+    async handleMode(chatId, userId, platform, arg) {
+        const defaultMode = this.deps.config.defaultPermissionMode;
+        const currentMode = getPermissionMode(userId, defaultMode);
+        if (arg) {
+            const parsed = parsePermissionMode(arg);
+            if (parsed) {
+                setPermissionMode(userId, parsed);
+                await this.deps.sender.sendTextReply(chatId, `✅ 权限模式已切换为 **${MODE_LABELS[parsed]}**\n${MODE_DESCRIPTIONS[parsed]}`);
+                return true;
+            }
+            await this.deps.sender.sendTextReply(chatId, `无效模式: ${arg}\n可用: ask, accept-edits, plan, yolo`);
+            return true;
+        }
+        if (platform === 'feishu' && this.deps.sender.sendModeCard) {
+            await this.deps.sender.sendModeCard(chatId, userId, currentMode);
+            return true;
+        }
+        if (platform === 'telegram' && this.deps.sender.sendModeKeyboard) {
+            await this.deps.sender.sendModeKeyboard(chatId, userId, currentMode);
+            return true;
+        }
+        const lines = [
+            `🔐 **权限模式** (当前: ${MODE_LABELS[currentMode]})`,
+            '',
+            ...['ask', 'accept-edits', 'plan', 'yolo'].map((m) => `• \`/mode ${m}\` - ${MODE_LABELS[m]}: ${MODE_DESCRIPTIONS[m]}`),
+        ];
+        await this.deps.sender.sendTextReply(chatId, lines.join('\n'));
+        return true;
+    }
+    getClearHistoryHint(platform) {
+        return platform === 'feishu'
+            ? '💡 提示：如需清除本对话的历史消息，请点击飞书聊天右上角「...」→ 清除聊天记录'
+            : '💡 提示：如需清除本对话的历史消息，请点击 Telegram 聊天右上角 ⋮ → 清除历史';
+    }
     async handleHelp(chatId, platform) {
         const help = [
             '📋 可用命令:',
             '',
             '/help - 显示帮助',
+            '/mode - 切换权限模式（安全/编辑放行/只读/YOLO）',
             '/new - 开始新会话（AI 上下文重置）',
             '/status - 显示状态',
             '/cd <路径> - 切换工作目录',
@@ -48,16 +87,15 @@ export class CommandHandler {
             '/allow (/y) - 允许权限请求',
             '/deny (/n) - 拒绝权限请求',
             '',
-            '💡 提示：清除聊天历史请点击 Telegram 右上角 ⋮ → 清除历史',
+            this.getClearHistoryHint(platform),
         ].join('\n');
         await this.deps.sender.sendTextReply(chatId, help);
         return true;
     }
-    async handleNew(chatId, userId) {
+    async handleNew(chatId, userId, platform) {
         const ok = this.deps.sessionManager.newSession(userId);
         await this.deps.sender.sendTextReply(chatId, ok
-            ? '✅ AI 会话已重置，下一条消息将使用全新上下文。\n\n' +
-                '💡 提示：如需清除本对话的历史消息，请点击 Telegram 聊天右上角 ⋮ → 清除历史'
+            ? `✅ AI 会话已重置，下一条消息将使用全新上下文。\n\n${this.getClearHistoryHint(platform)}`
             : '当前没有活动会话。');
         return true;
     }
@@ -82,7 +120,7 @@ export class CommandHandler {
         await this.deps.sender.sendTextReply(chatId, lines.join('\n'));
         return true;
     }
-    async handleCd(chatId, userId, dir) {
+    async handleCd(chatId, userId, dir, platform) {
         // 如果 dir 为空，显示目录选择界面
         if (!dir) {
             const currentDir = this.deps.sessionManager.getWorkDir(userId);
@@ -98,7 +136,7 @@ export class CommandHandler {
             const resolved = await this.deps.sessionManager.setWorkDir(userId, dir);
             await this.deps.sender.sendTextReply(chatId, `📁 工作目录已切换到: ${resolved}\n\n` +
                 `🔄 AI 会话已重置，下一条消息将使用全新上下文。\n` +
-                `💡 提示：如需清除本对话的历史消息，请点击 Telegram 聊天右上角 ⋮ → 清除历史`);
+                this.getClearHistoryHint(platform));
         }
         catch (err) {
             await this.deps.sender.sendTextReply(chatId, err instanceof Error ? err.message : String(err));

package/dist/config.d.ts

@@ -14,6 +14,7 @@ export interface Config {
     claudeWorkDir: string;
     allowedBaseDirs: string[];
     claudeSkipPermissions: boolean;
+    defaultPermissionMode: 'ask' | 'accept-edits' | 'plan' | 'yolo';
     claudeTimeoutMs: number;
     claudeModel?: string;
     hookPort: number;

package/dist/config.js

@@ -84,6 +84,7 @@ export function loadConfig() {
     const claudeSkipPermissions = process.env.CLAUDE_SKIP_PERMISSIONS !== undefined
         ? process.env.CLAUDE_SKIP_PERMISSIONS === 'true'
         : file.claudeSkipPermissions ?? true;
+    const defaultPermissionMode = (file.defaultPermissionMode ?? 'ask');
     const claudeTimeoutMs = process.env.CLAUDE_TIMEOUT_MS !== undefined
         ? parseInt(process.env.CLAUDE_TIMEOUT_MS, 10) || 600000
         : file.claudeTimeoutMs ?? 600000;
@@ -167,6 +168,7 @@ export function loadConfig() {
         claudeWorkDir,
         allowedBaseDirs,
         claudeSkipPermissions,
+        defaultPermissionMode,
         claudeTimeoutMs,
         claudeModel: process.env.CLAUDE_MODEL ?? file.claudeModel,
         hookPort,

package/dist/feishu/client.d.ts

@@ -1,5 +1,5 @@
 import { Client } from '@larksuiteoapi/node-sdk';
 import type { Config } from '../config.js';
 export declare function getClient(): Client;
-export declare function initFeishu(config: Config, eventHandler: (data: unknown) => Promise<void>): Promise<void>;
+export declare function initFeishu(config: Config, eventHandler: (data: unknown) => Promise<void | Record<string, unknown>>): Promise<void>;
 export declare function stopFeishu(): void;

package/dist/feishu/client.js

@@ -34,6 +34,19 @@ export async function initFeishu(config, eventHandler) {
                 log.error('[EVENT] Error calling event handler:', err);
             }
         },
+        // 卡片按钮点击回调（权限允许/拒绝等）
+        'card.action.trigger': async (data) => {
+            log.info('[EVENT] Received Feishu card action event');
+            log.info('[EVENT] Card action data:', JSON.stringify(data).slice(0, 800));
+            try {
+                const result = await eventHandler(data);
+                return result;
+            }
+            catch (err) {
+                log.error('[EVENT] Error handling card action:', err);
+                return { toast: { type: 'error', content: '处理失败' } };
+            }
+        },
     });
     // Register catch-all handler using wildcard
     eventDispatcher.register({

package/dist/feishu/event-handler.d.ts

@@ -3,6 +3,6 @@ import type { SessionManager } from '../session/session-manager.js';
 export interface FeishuEventHandlerHandle {
     stop: () => void;
     getRunningTaskCount: () => number;
-    handleEvent: (data: unknown) => Promise<void>;
+    handleEvent: (data: unknown) => Promise<void | Record<string, unknown>>;
 }
 export declare function setupFeishuHandlers(config: Config, sessionManager: SessionManager): FeishuEventHandlerHandle;

package/dist/feishu/event-handler.js

@@ -2,14 +2,17 @@ import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { AccessControl } from '../access/access-control.js';
 import { RequestQueue } from '../queue/request-queue.js';
-import { sendThinkingMessage, updateMessage, sendFinalMessages, sendTextReply, startTypingLoop, sendImageReply, createFeishuButtonCard, } from './message-sender.js';
+import { sendThinkingMessage, updateMessage, sendFinalMessages, sendTextReply, sendTextReplyByOpenId, startTypingLoop, sendImageReply, createFeishuButtonCard, sendModeCard, createFeishuModeCardReadOnly, delayUpdateCard, } from './message-sender.js';
 import { registerPermissionSender, resolvePermissionById } from '../hook/permission-server.js';
+import { setPermissionMode } from '../permission-mode/session-mode.js';
+import { MODE_LABELS } from '../permission-mode/types.js';
 import { CommandHandler } from '../commands/handler.js';
 import { getAdapter } from '../adapters/registry.js';
 import { runAITask } from '../shared/ai-task.js';
 import { startTaskCleanup } from '../shared/task-cleanup.js';
 import { THROTTLE_MS, IMAGE_DIR } from '../constants.js';
 import { setActiveChatId } from '../shared/active-chats.js';
+import { setChatUser } from '../shared/chat-user-map.js';
 import { createLogger } from '../logger.js';
 const log = createLogger('FeishuHandler');
 async function downloadFeishuImage(client, imageKey) {
@@ -107,7 +110,7 @@ export function setupFeishuHandlers(config, sessionManager) {
         config,
         sessionManager,
         requestQueue,
-        sender: { sendTextReply },
+        sender: { sendTextReply, sendModeCard },
         getRunningTasksSize: () => runningTasks.size,
     });
     registerPermissionSender('feishu', { sendTextReply, sendPermissionCard });
@@ -162,62 +165,181 @@ export function setupFeishuHandlers(config, sessionManager) {
             sendImage: (path) => sendImageReply(chatId, path),
         });
     }
+    /**
+     * Parse permission button value from card action (兼容多种格式)
+     */
+    function parsePermissionActionValue(raw) {
+        if (!raw)
+            return null;
+        let buttonValue;
+        if (typeof raw === 'string') {
+            try {
+                const parsed = JSON.parse(raw);
+                if (parsed.action === 'permission' && parsed.value)
+                    buttonValue = parsed.value;
+                else if (raw.startsWith('allow_') || raw.startsWith('deny_'))
+                    buttonValue = raw;
+            }
+            catch {
+                if (raw.startsWith('allow_') || raw.startsWith('deny_'))
+                    buttonValue = raw;
+            }
+        }
+        else if (typeof raw === 'object' && raw !== null) {
+            const obj = raw;
+            if (obj.action === 'permission' && obj.value)
+                buttonValue = obj.value;
+        }
+        if (!buttonValue)
+            return null;
+        if (buttonValue.startsWith('allow_')) {
+            return { decision: 'allow', requestId: buttonValue.slice(6) };
+        }
+        if (buttonValue.startsWith('deny_')) {
+            return { decision: 'deny', requestId: buttonValue.slice(5) };
+        }
+        return null;
+    }
+    /**
+     * 解析 action value（兼容对象、JSON 字符串）
+     */
+    function parseActionValue(raw) {
+        if (!raw)
+            return null;
+        let obj = null;
+        if (typeof raw === 'string') {
+            try {
+                obj = JSON.parse(raw);
+            }
+            catch {
+                return null;
+            }
+        }
+        else if (typeof raw === 'object' && raw !== null) {
+            obj = raw;
+        }
+        return obj?.action && obj?.value ? obj : null;
+    }
+    /**
+     * 从卡片回调事件中提取延时更新 token（格式 c-xxxx）
+     * 飞书文档：从卡片交互返回内容获取，用于延时更新接口
+     */
+    function extractCardToken(data) {
+        const raw = data;
+        const event = (raw?.event ?? raw);
+        const action = event?.action;
+        const context = event?.context;
+        const candidates = [
+            event?.token,
+            event?.open_api_token,
+            raw?.token,
+            action?.token,
+            context?.token,
+        ].filter((t) => typeof t === 'string' && t.startsWith('c-'));
+        const token = candidates[0] ?? null;
+        if (!token) {
+            log.debug('[extractCardToken] No token found, event keys:', Object.keys(event ?? {}));
+        }
+        return token;
+    }
+    /**
+     * Handle card button click (card.action.trigger) - 需在 3 秒内返回响应
+     * 同步只返回 toast，避免 200672；用延时更新 API 异步替换为只读卡片，防止二次点击
+     */
+    async function handleCardAction(data) {
+        // 兼容 SDK 可能嵌套的 event 结构
+        const wrapped = data;
+        const event = (wrapped?.event ?? data);
+        const actionValue = event?.action?.value;
+        const chatId = event?.context?.open_chat_id ?? event?.context?.chat_id ?? event?.context?.open_id ?? '';
+        const userId = event?.sender?.sender_id?.open_id ?? '';
+        log.info(`[handleCardAction] chatId=${chatId}, userId=${userId}, actionValue=${JSON.stringify(actionValue)}`);
+        // 处理 mode 按钮（兼容 value 为对象或 JSON 字符串）
+        const modeAv = parseActionValue(actionValue);
+        if (modeAv?.action === 'mode' && modeAv.value) {
+            const mode = modeAv.value;
+            if (['ask', 'accept-edits', 'plan', 'yolo'].includes(mode)) {
+                setPermissionMode(userId, mode);
+                const toastContent = `✅ 已切换为 ${MODE_LABELS[mode]}`;
+                const label = MODE_LABELS[mode];
+                // 异步发送文本回复，不阻塞 3 秒内返回
+                const sendReply = () => {
+                    if (chatId)
+                        return sendTextReply(chatId, toastContent);
+                    if (userId)
+                        return sendTextReplyByOpenId(userId, toastContent);
+                    log.warn('[handleCardAction] No chatId/userId, cannot send text reply');
+                };
+                const p = sendReply();
+                if (p)
+                    p.catch((e) => log.warn('[handleCardAction] Send reply failed:', e));
+                // 同步只返回 toast，避免 200672（同步返回 card 格式易出错）
+                const cardToken = extractCardToken(data);
+                const readOnlyCard = createFeishuModeCardReadOnly(label);
+                if (cardToken && userId) {
+                    // 延时更新：异步替换为只读卡片，防止二次点击
+                    delayUpdateCard(cardToken, readOnlyCard, [userId]).catch((e) => log.warn('[handleCardAction] delayUpdateCard failed:', e));
+                }
+                else if (!cardToken) {
+                    log.debug('[handleCardAction] No card token in event, cannot delay-update card');
+                }
+                return { toast: { type: 'success', content: toastContent } };
+            }
+        }
+        const parsed = parsePermissionActionValue(actionValue);
+        if (!parsed) {
+            log.info('[handleCardAction] Unrecognized action value, returning default toast');
+            return { toast: { type: 'warning', content: '未知操作' } };
+        }
+        const { decision, requestId } = parsed;
+        log.info(`[handleCardAction] Permission button: ${decision} for ${requestId}, chatId=${chatId}`);
+        const resolved = resolvePermissionById(requestId, decision);
+        const toastContent = resolved
+            ? decision === 'allow'
+                ? '✅ 权限已允许'
+                : '❌ 权限已拒绝'
+            : '⚠️ 权限请求已过期或不存在';
+        const sendPermReply = () => {
+            if (chatId)
+                return sendTextReply(chatId, toastContent);
+            if (userId)
+                return sendTextReplyByOpenId(userId, toastContent);
+        };
+        const permP = sendPermReply();
+        if (permP)
+            permP.catch((err) => log.warn('Failed to send permission reply:', err));
+        return { toast: { type: resolved ? 'success' : 'warning', content: toastContent } };
+    }
     async function handleEvent(data) {
-        log.info('[handleEvent] Called with data:', JSON.stringify(data).slice(0, 500));
+        log.info('[handleEvent] Called with data:', JSON.stringify(data).slice(0, 800));
         try {
-            log.info('[handleEvent] Starting processing');
-            // Parse the event data
-            // Feishu event structure (long connection mode):
-            // {
-            //   "event_type": "im.message.receive_v1",
-            //   "event_id": "...",
-            //   "tenant_key": "...",
-            //   "app_id": "...",
-            //   "message": { "chat_id": "...", "content": "...", ... },
-            //   "sender": { "sender_id": { "open_id": "..." } }
-            //   "action": {  // For card button clicks
-            //     "action_id": "...",
-            //     "value": { "action": "permission", "value": "allow_xxx" }
-            //   }
-            // }
-            const event = data;
-            const eventType = event?.event_type;
+            const raw = data;
+            const event = (raw?.event ?? raw);
+            const eventType = event?.event_type ?? event?.type;
             log.info('Feishu event type:', eventType);
-            // Handle message received events
+            // 1. 卡片按钮点击 (card.action.trigger) - 需快速返回响应
+            if (eventType === 'card.action.trigger') {
+                const result = await handleCardAction(data);
+                return result ?? { toast: { type: 'success', content: '已处理' } };
+            }
+            // 2. 消息接收 (im.message.receive_v1)
             if (eventType === 'im.message.receive_v1') {
                 log.info('[handleEvent] Processing im.message.receive_v1 event');
-                // Check if this is a card button click event
-                // For interactive cards, the action is in a different location
-                if (event?.action) {
-                    const action = event.action;
-                    log.info('[handleEvent] Card action detected:', action);
-                    if (action?.value) {
-                        const actionValue = action.value;
-                        if (actionValue.action === 'permission' && actionValue.value) {
-                            const buttonValue = actionValue.value;
-                            let decision = null;
-                            let requestId = null;
-                            if (buttonValue.startsWith('allow_')) {
-                                decision = 'allow';
-                                requestId = buttonValue.slice(6);
-                            }
-                            else if (buttonValue.startsWith('deny_')) {
-                                decision = 'deny';
-                                requestId = buttonValue.slice(5);
-                            }
-                            if (decision && requestId) {
-                                log.info(`[handleEvent] Permission button clicked: ${decision} for ${requestId}`);
-                                const resolved = resolvePermissionById(requestId, decision);
-                                const chatId = event.message?.chat_id ?? '';
-                                if (resolved) {
-                                    await sendTextReply(chatId, decision === 'allow' ? '✅ 权限已允许' : '❌ 权限已拒绝');
-                                }
-                                else {
-                                    await sendTextReply(chatId, '⚠️ 权限请求已过期或不存在');
-                                }
-                                return;
-                            }
+                // 兼容：部分场景下卡片点击可能通过 im.message 携带 action
+                if (event?.action?.value) {
+                    const parsed = parsePermissionActionValue(event.action.value);
+                    if (parsed) {
+                        const { decision, requestId } = parsed;
+                        const chatId = event.message?.chat_id ?? '';
+                        log.info(`[handleEvent] Permission (via msg): ${decision} for ${requestId}`);
+                        const resolved = resolvePermissionById(requestId, decision);
+                        if (resolved) {
+                            await sendTextReply(chatId, decision === 'allow' ? '✅ 权限已允许' : '❌ 权限已拒绝');
                         }
+                        else {
+                            await sendTextReply(chatId, '⚠️ 权限请求已过期或不存在');
+                        }
+                        return;
                     }
                 }
                 const message = event?.message;
@@ -256,6 +378,7 @@ export function setupFeishuHandlers(config, sessionManager) {
                 }
                 log.info(`Access granted for sender: ${senderId}`);
                 setActiveChatId('feishu', chatId);
+                setChatUser(chatId, senderId);
                 // Handle different message types
                 if (msgType === 'text') {
                     const text = content.text?.trim() ?? '';
@@ -289,39 +412,42 @@ export function setupFeishuHandlers(config, sessionManager) {
                 }
                 else if (msgType === 'post') {
                     // Feishu rich text/post messages - extract text content
-                    const post = content?.post;
+                    // 支持 post.content 或 zh_cn.content，content 可能是二维数组（段落→元素）
+                    const post = content?.post
+                        ?? content?.zh_cn;
+                    const rawContent = post?.content;
                     let text = '';
-                    if (post?.content && Array.isArray(post.content)) {
-                        // Log full structure for debugging
-                        log.info(`[MSG] Post content structure:`, JSON.stringify(post.content).slice(0, 500));
-                        // Extract text from rich text structure
-                        for (const section of post.content) {
-                            if (!section || typeof section !== 'object')
-                                continue;
-                            const tag = section?.tag;
-                            // Handle different content types
-                            if (tag === 'text' || tag === 'plain_text') {
-                                const t = section?.text ?? '';
-                                text += t;
+                    function extractTextFromElement(el) {
+                        if (!el || typeof el !== 'object')
+                            return '';
+                        const obj = el;
+                        const tag = obj.tag;
+                        if (tag === 'text' || tag === 'plain_text') {
+                            return (obj.text ?? obj.content ?? '').toString();
+                        }
+                        if (tag === 'a')
+                            return (obj.text ?? obj.content ?? '').toString();
+                        if (tag === 'heading' || tag === 'heading1' || tag === 'heading2' || tag === 'heading3') {
+                            const headingText = el.text;
+                            if (typeof headingText === 'string')
+                                return headingText;
+                            if (Array.isArray(headingText)) {
+                                return headingText.map(extractTextFromElement).join('');
                             }
-                            else if (tag === 'heading' || tag === 'heading1' || tag === 'heading2' || tag === 'heading3') {
-                                // Handle headings - might be nested structure
-                                const headingText = section?.text;
-                                if (typeof headingText === 'string') {
-                                    text += headingText;
-                                }
-                                else if (Array.isArray(headingText)) {
-                                    // Nested text elements in heading
-                                    for (const item of headingText) {
-                                        if (item && typeof item === 'object' && 'text' in item) {
-                                            text += item.text ?? '';
-                                        }
-                                    }
+                        }
+                        return '';
+                    }
+                    if (rawContent && Array.isArray(rawContent)) {
+                        log.info(`[MSG] Post content structure:`, JSON.stringify(rawContent).slice(0, 500));
+                        for (const section of rawContent) {
+                            if (Array.isArray(section)) {
+                                // 二维数组：段落内多个元素
+                                for (const el of section) {
+                                    text += extractTextFromElement(el);
                                 }
                             }
                             else {
-                                // Log unhandled tags for debugging
-                                log.info(`[MSG] Unhandled post tag: ${tag}, section:`, JSON.stringify(section).slice(0, 200));
+                                text += extractTextFromElement(section);
                             }
                         }
                     }

package/dist/feishu/message-sender.d.ts

@@ -8,9 +8,22 @@ export declare function createFeishuButtonCard(title: string, content: string, b
     value: string;
     type?: 'primary' | 'default';
 }>): string;
+/** 只读模式卡片（无按钮，用于回调后替换原卡片防止二次点击） */
+export declare function createFeishuModeCardReadOnly(currentMode: string): Record<string, unknown>;
+/**
+ * 延时更新消息卡片（POST /open-apis/im/v1/cards/update）
+ * 用于在卡片回调 3 秒内无法完成时，异步替换卡片为只读版本，防止二次点击
+ * @param token 从卡片交互事件中获取的 token（格式 c-xxxx）
+ * @param card 卡片内容 { config, header, elements }
+ * @param openIds 非共享卡片需指定更新的用户 open_id 列表
+ */
+export declare function delayUpdateCard(token: string, card: Record<string, unknown>, openIds?: string[]): Promise<void>;
+export declare function sendModeCard(chatId: string, _userId: string, currentMode: string): Promise<void>;
 export declare function sendThinkingMessage(chatId: string, replyToMessageId: string | undefined, toolId?: string): Promise<string>;
 export declare function updateMessage(chatId: string, messageId: string, content: string, status: MessageStatus, note?: string, toolId?: string): Promise<void>;
 export declare function sendFinalMessages(chatId: string, messageId: string, fullContent: string, note: string, toolId?: string): Promise<void>;
 export declare function sendTextReply(chatId: string, text: string): Promise<void>;
+/** 使用 open_id 发送（私聊时 context 可能只有 open_id） */
+export declare function sendTextReplyByOpenId(openId: string, text: string): Promise<void>;
 export declare function sendImageReply(chatId: string, imagePath: string): Promise<void>;
 export declare function startTypingLoop(_chatId: string): () => void;

package/dist/feishu/message-sender.js

@@ -114,6 +114,108 @@ export function createFeishuButtonCard(title, content, buttons) {
     };
     return JSON.stringify(card);
 }
+/** 只读模式卡片（无按钮，用于回调后替换原卡片防止二次点击） */
+export function createFeishuModeCardReadOnly(currentMode) {
+    return {
+        config: { wide_screen_mode: true },
+        header: {
+            template: 'green',
+            title: { content: '🔐 权限模式', tag: 'plain_text' },
+        },
+        elements: [
+            {
+                tag: 'div',
+                text: {
+                    tag: 'lark_md',
+                    content: `**当前模式:** ${currentMode}\n\n✅ 已切换成功，发送 \`/mode\` 可再次切换。`,
+                },
+            },
+        ],
+    };
+}
+/**
+ * 延时更新消息卡片（POST /open-apis/im/v1/cards/update）
+ * 用于在卡片回调 3 秒内无法完成时，异步替换卡片为只读版本，防止二次点击
+ * @param token 从卡片交互事件中获取的 token（格式 c-xxxx）
+ * @param card 卡片内容 { config, header, elements }
+ * @param openIds 非共享卡片需指定更新的用户 open_id 列表
+ */
+export async function delayUpdateCard(token, card, openIds) {
+    const accessToken = await getTenantAccessToken();
+    // 非共享卡片需在 card 内指定 open_ids
+    const cardBody = { ...card };
+    if (openIds && openIds.length > 0) {
+        cardBody.open_ids = openIds;
+    }
+    const body = { token, card: cardBody };
+    const resp = await fetch('https://open.feishu.cn/open-apis/interactive/v1/card/update', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${accessToken}`,
+        },
+        body: JSON.stringify(body),
+    });
+    const data = (await resp.json());
+    if (data.code !== 0) {
+        log.warn(`[delayUpdateCard] Failed: code=${data.code}, msg=${data.msg}`);
+        return;
+    }
+    log.info('[delayUpdateCard] Card updated successfully');
+}
+/**
+ * Create mode switch card with action type for card callback
+ */
+function createFeishuModeCard(currentMode, buttons) {
+    const elements = [];
+    elements.push({
+        tag: 'div',
+        text: {
+            tag: 'lark_md',
+            content: `**当前模式:** ${currentMode}\n\n点击下方按钮切换模式：\n\n_💡 若点击报错：开放平台 → 事件与回调 → 切到「回调」Tab → 添加「卡片回传交互」。或直接用 \`/mode ask\` 等命令切换。_`,
+        },
+    });
+    elements.push({ tag: 'hr' });
+    for (let i = 0; i < buttons.length; i += 4) {
+        const row = buttons.slice(i, i + 4).map((btn) => ({
+            tag: 'button',
+            text: { tag: 'plain_text', content: btn.label },
+            type: btn.type || 'default',
+            value: { action: 'mode', value: btn.value },
+        }));
+        elements.push({ tag: 'action', actions: row });
+    }
+    const card = {
+        config: { wide_screen_mode: true },
+        header: {
+            template: 'blue',
+            title: { content: '🔐 权限模式', tag: 'plain_text' },
+        },
+        elements,
+    };
+    return JSON.stringify(card);
+}
+export async function sendModeCard(chatId, _userId, currentMode) {
+    const { getClient } = await import('./client.js');
+    const { MODE_LABELS } = await import('../permission-mode/types.js');
+    const client = getClient();
+    const MODE_BTNS = [
+        { label: MODE_LABELS.ask, value: 'ask', type: 'default' },
+        { label: MODE_LABELS['accept-edits'], value: 'accept-edits', type: 'default' },
+        { label: MODE_LABELS.plan, value: 'plan', type: 'default' },
+        { label: MODE_LABELS.yolo, value: 'yolo', type: 'default' },
+    ];
+    const currentLabel = MODE_BTNS.find((b) => b.value === currentMode)?.label ?? currentMode;
+    const cardContent = createFeishuModeCard(currentLabel, MODE_BTNS);
+    await client.im.message.create({
+        data: {
+            receive_id: chatId,
+            msg_type: 'interactive',
+            content: cardContent,
+        },
+        params: { receive_id_type: 'chat_id' },
+    });
+}
 async function getTenantAccessToken() {
     const client = getClient();
     const resp = await client.auth.tenantAccessToken.internal({
@@ -153,8 +255,7 @@ export async function sendThinkingMessage(chatId, replyToMessageId, toolId = 'cl
 }
 export async function updateMessage(chatId, messageId, content, status, note, toolId = 'claude') {
     const client = getClient();
-    const icon = STATUS_CONFIG[status].icon;
-    const title = `${icon} ${getToolTitle(toolId, status)}`;
+    const title = getToolTitle(toolId, status);
     const cardContent = createFeishuCard(title, content, status, note);
     // Try to use patch API for in-place update (streaming)
     try {
@@ -276,6 +377,24 @@ export async function sendTextReply(chatId, text) {
         log.error('Failed to send text:', err);
     }
 }
+/** 使用 open_id 发送（私聊时 context 可能只有 open_id） */
+export async function sendTextReplyByOpenId(openId, text) {
+    const client = getClient();
+    const cardContent = createFeishuCard('📢 open-im', text, 'done');
+    try {
+        await client.im.message.create({
+            data: {
+                receive_id: openId,
+                msg_type: 'interactive',
+                content: cardContent,
+            },
+            params: { receive_id_type: 'open_id' },
+        });
+    }
+    catch (err) {
+        log.error('Failed to send text by open_id:', err);
+    }
+}
 export async function sendImageReply(chatId, imagePath) {
     const client = getClient();
     try {

package/dist/hook/permission-server.d.ts

@@ -1,8 +1,9 @@
 /**
  * Permission Server - Handles tool permission requests from Claude CLI
  *
- * When claudeSkipPermissions is false, Claude CLI will make HTTP requests
- * to this server to ask for user approval before running tools.
+ * When claudeSkipPermissions is false and not in yolo mode, Claude CLI will make
+ * HTTP requests to this server. We forward all requests to the user for approval;
+ * permission mode logic (ask/accept-edits/plan) is handled by Claude via --permission-mode.
  */
 interface MessageSender {
     sendTextReply(chatId: string, text: string): Promise<void>;

package/dist/hook/permission-server.js

@@ -1,8 +1,9 @@
 /**
  * Permission Server - Handles tool permission requests from Claude CLI
  *
- * When claudeSkipPermissions is false, Claude CLI will make HTTP requests
- * to this server to ask for user approval before running tools.
+ * When claudeSkipPermissions is false and not in yolo mode, Claude CLI will make
+ * HTTP requests to this server. We forward all requests to the user for approval;
+ * permission mode logic (ask/accept-edits/plan) is handled by Claude via --permission-mode.
  */
 import { createServer } from 'node:http';
 import { createLogger } from '../logger.js';
@@ -148,35 +149,36 @@ function handlePermissionRequest(req, res) {
     req.on('end', async () => {
         try {
             const data = JSON.parse(body);
-            const { requestId, toolName, toolInput } = data;
+            const requestId = String(data.requestId ?? '');
+            const toolName = String(data.toolName ?? '');
+            const toolInput = data.toolInput;
+            const chatId = (typeof data.chatId === 'string' ? data.chatId : null) ??
+                (typeof data.chat_id === 'string' ? data.chat_id : null) ??
+                process.env.CC_IM_CHAT_ID ??
+                undefined;
             if (!requestId || !toolName) {
                 res.writeHead(400, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({ error: 'Missing required fields' }));
                 return;
             }
-            // Get chatId from environment (set by CC_IM_CHAT_ID)
-            const chatId = process.env.CC_IM_CHAT_ID;
             if (!chatId) {
-                log.warn('No chatId in environment, auto-allowing permission');
+                log.warn('No chatId, auto-allowing permission');
                 res.writeHead(200, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({ allowed: true }));
                 return;
             }
-            // Check if skip permissions is enabled
             if (process.env.CC_SKIP_PERMISSIONS === 'true') {
                 log.info(`Skip permissions enabled, auto-allowing ${toolName}`);
                 res.writeHead(200, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({ allowed: true }));
                 return;
             }
-            // Check if already resolved (race condition)
             if (pendingRequests.has(requestId)) {
                 log.warn(`Duplicate permission request: ${requestId}`);
                 res.writeHead(409, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({ error: 'Duplicate request' }));
                 return;
             }
-            // Send pending response
             res.writeHead(202, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ status: 'pending' }));
             // Create permission request

package/dist/index.js

@@ -17,6 +17,7 @@ import { loadActiveChats, getActiveChatId, flushActiveChats, } from "./shared/ac
 import { initLogger, createLogger, closeLogger } from "./logger.js";
 import { APP_HOME, SHUTDOWN_PORT } from "./constants.js";
 import { startPermissionServer, stopPermissionServer } from "./hook/permission-server.js";
+import { initPermissionModes } from "./permission-mode/session-mode.js";
 import { createRequire } from "node:module";
 const require = createRequire(import.meta.url);
 const { version: APP_VERSION } = require("../package.json");
@@ -46,13 +47,17 @@ export async function main() {
     const config = loadConfig();
     initLogger(config.logDir, config.logLevel);
     loadActiveChats();
+    initPermissionModes();
     initAdapters(config);
     // Start permission server for tool approval
     const actualPort = startPermissionServer(config.hookPort);
     log.info(`Permission server listening on port ${actualPort}`);
+    const { MODE_LABELS } = await import('./permission-mode/types.js');
+    const defaultModeLabel = MODE_LABELS[config.defaultPermissionMode];
     log.info("Starting open-im bridge...");
     log.info(`AI 工具: ${config.aiCommand}`);
     log.info(`工作目录: ${config.claudeWorkDir}`);
+    log.info(`默认权限模式: ${defaultModeLabel} (${config.defaultPermissionMode})`);
     log.info(`启用平台: ${config.enabledPlatforms.join(", ")}`);
     const sessionManager = new SessionManager(config.claudeWorkDir, config.allowedBaseDirs);
     let telegramHandle = null;
@@ -72,6 +77,7 @@ export async function main() {
         "",
         `AI 工具: ${config.aiCommand}`,
         `工作目录: ${config.claudeWorkDir}`,
+        `默认权限模式: ${defaultModeLabel} (${config.defaultPermissionMode})`,
         `启用平台: ${config.enabledPlatforms.join(", ")}`,
     ].join("\n");
     // Send notification to all enabled platforms

package/dist/permission-mode/session-mode.d.ts

@@ -0,0 +1,7 @@
+import type { PermissionMode } from './types.js';
+/** 初始化（启动时调用） */
+export declare function initPermissionModes(): void;
+/** 获取用户当前权限模式 */
+export declare function getPermissionMode(userId: string, defaultMode?: PermissionMode): PermissionMode;
+/** 设置用户权限模式 */
+export declare function setPermissionMode(userId: string, mode: PermissionMode): void;

package/dist/permission-mode/session-mode.js

@@ -0,0 +1,59 @@
+/**
+ * 按用户存储权限模式，支持运行时切换
+ */
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { APP_HOME } from '../constants.js';
+import { createLogger } from '../logger.js';
+import { PERMISSION_MODES } from './types.js';
+const log = createLogger('PermissionMode');
+const MODE_FILE = join(APP_HOME, 'data', 'permission-modes.json');
+let modes = new Map();
+let saveTimer = null;
+function isValidMode(v) {
+    return typeof v === 'string' && PERMISSION_MODES.includes(v);
+}
+function load() {
+    try {
+        if (existsSync(MODE_FILE)) {
+            const data = JSON.parse(readFileSync(MODE_FILE, 'utf-8'));
+            modes = new Map(Object.entries(data).filter(([, v]) => isValidMode(v)));
+        }
+    }
+    catch {
+        modes = new Map();
+    }
+}
+function scheduleSave() {
+    if (saveTimer)
+        return;
+    saveTimer = setTimeout(() => {
+        saveTimer = null;
+        try {
+            const dir = dirname(MODE_FILE);
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            const obj = {};
+            for (const [k, v] of modes)
+                obj[k] = v;
+            writeFileSync(MODE_FILE, JSON.stringify(obj, null, 2), 'utf-8');
+        }
+        catch (err) {
+            log.error('Failed to save permission modes:', err);
+        }
+    }, 300);
+}
+/** 初始化（启动时调用） */
+export function initPermissionModes() {
+    load();
+}
+/** 获取用户当前权限模式 */
+export function getPermissionMode(userId, defaultMode = 'ask') {
+    return modes.get(userId) ?? defaultMode;
+}
+/** 设置用户权限模式 */
+export function setPermissionMode(userId, mode) {
+    modes.set(userId, mode);
+    scheduleSave();
+    log.info(`Permission mode for ${userId}: ${mode}`);
+}

package/dist/permission-mode/types.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 权限模式类型定义
+ * 与 Claude Code 官方命名一致: default | acceptEdits | plan | bypassPermissions
+ * 见 https://code.claude.com/docs/en/permissions
+ */
+export type PermissionMode = 'ask' | 'accept-edits' | 'plan' | 'yolo';
+export declare const PERMISSION_MODES: PermissionMode[];
+/** Claude Code 官方模式名（用于显示） */
+export declare const MODE_LABELS: Record<PermissionMode, string>;
+export declare const MODE_DESCRIPTIONS: Record<PermissionMode, string>;
+export declare function parsePermissionMode(raw: string): PermissionMode | null;

package/dist/permission-mode/types.js

@@ -0,0 +1,29 @@
+export const PERMISSION_MODES = ['ask', 'accept-edits', 'plan', 'yolo'];
+/** Claude Code 官方模式名（用于显示） */
+export const MODE_LABELS = {
+    ask: 'default',
+    'accept-edits': 'acceptEdits',
+    plan: 'plan',
+    yolo: 'bypassPermissions',
+};
+export const MODE_DESCRIPTIONS = {
+    ask: '首次使用每个工具时提示确认',
+    'accept-edits': '编辑权限自动通过',
+    plan: '仅分析，不修改文件不执行命令',
+    yolo: '跳过所有权限确认',
+};
+export function parsePermissionMode(raw) {
+    const s = raw.trim().toLowerCase();
+    if (PERMISSION_MODES.includes(s))
+        return s;
+    const aliases = {
+        safe: 'ask',
+        default: 'ask',
+        edit: 'accept-edits',
+        edits: 'accept-edits',
+        read: 'plan',
+        readonly: 'plan',
+        bypass: 'yolo',
+    };
+    return aliases[s] ?? null;
+}

package/dist/shared/ai-task.js

@@ -1,6 +1,7 @@
 /**
  * 共享 AI 任务执行层 - 支持多 ToolAdapter
  */
+import { getPermissionMode } from '../permission-mode/session-mode.js';
 import { formatToolStats, formatToolCallNotification, getContextWarning, } from './utils.js';
 import { createLogger } from '../logger.js';
 const log = createLogger('AITask');
@@ -69,6 +70,19 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
                 }, platformAdapter.throttleMs - elapsed);
             }
         };
+        const mode = getPermissionMode(ctx.userId, config.defaultPermissionMode);
+        // 全部交给 Claude 自己处理：yolo 用 --dangerously-skip-permissions，其他用 --permission-mode
+        const skipPermissions = mode === 'yolo' || config.claudeSkipPermissions;
+        const permissionMode = !skipPermissions
+            ? (mode === 'ask'
+                ? 'default'
+                : mode === 'accept-edits'
+                    ? 'acceptEdits'
+                    : mode === 'plan'
+                        ? 'plan'
+                        : undefined)
+            : undefined;
+        process.env.CC_IM_CHAT_ID = ctx.chatId;
         const handle = toolAdapter.run(prompt, ctx.sessionId, ctx.workDir, {
             onSessionId: (id) => {
                 if (ctx.threadId)
@@ -149,7 +163,8 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
                 resolve();
             },
         }, {
-            skipPermissions: config.claudeSkipPermissions,
+            skipPermissions,
+            permissionMode,
             timeoutMs: config.claudeTimeoutMs,
             model: sessionManager.getModel(ctx.userId, ctx.threadId) ?? config.claudeModel,
             chatId: ctx.chatId,

package/dist/shared/chat-user-map.d.ts

@@ -0,0 +1,2 @@
+export declare function setChatUser(chatId: string, userId: string): void;
+export declare function getUserIdByChatId(chatId: string): string | undefined;

package/dist/shared/chat-user-map.js

@@ -0,0 +1,11 @@
+/**
+ * chatId -> userId 映射，用于权限请求时根据 chatId 查找用户
+ * 在用户发送消息时更新
+ */
+const chatToUser = new Map();
+export function setChatUser(chatId, userId) {
+    chatToUser.set(chatId, userId);
+}
+export function getUserIdByChatId(chatId) {
+    return chatToUser.get(chatId);
+}

package/dist/telegram/event-handler.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { message } from "telegraf/filters";
 import { AccessControl } from "../access/access-control.js";
 import { RequestQueue } from "../queue/request-queue.js";
-import { sendThinkingMessage, updateMessage, sendFinalMessages, sendTextReply, startTypingLoop, sendImageReply, } from "./message-sender.js";
+import { sendThinkingMessage, updateMessage, sendFinalMessages, sendTextReply, startTypingLoop, sendImageReply, sendModeKeyboard, sendDirectorySelection, } from "./message-sender.js";
 import { registerPermissionSender, resolvePermissionById, } from "../hook/permission-server.js";
 import { CommandHandler } from "../commands/handler.js";
 import { getAdapter } from "../adapters/registry.js";
@@ -11,6 +11,9 @@ import { runAITask } from "../shared/ai-task.js";
 import { startTaskCleanup } from "../shared/task-cleanup.js";
 import { TELEGRAM_THROTTLE_MS, IMAGE_DIR } from "../constants.js";
 import { setActiveChatId } from "../shared/active-chats.js";
+import { setChatUser } from "../shared/chat-user-map.js";
+import { setPermissionMode } from "../permission-mode/session-mode.js";
+import { MODE_LABELS } from "../permission-mode/types.js";
 import { createLogger } from "../logger.js";
 const log = createLogger("TgHandler");
 // 动态节流器类 - 根据内容长度和更新频率调整间隔
@@ -74,7 +77,7 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
         config,
         sessionManager,
         requestQueue,
-        sender: { sendTextReply },
+        sender: { sendTextReply, sendDirectorySelection, sendModeKeyboard },
         getRunningTasksSize: () => runningTasks.size,
     });
     registerPermissionSender("telegram", { sendTextReply });
@@ -310,6 +313,16 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
             resolvePermissionById(requestId, decision);
             await ctx.answerCbQuery(isAllow ? "✅ 已允许" : "❌ 已拒绝");
         }
+        else if (data.startsWith("mode:")) {
+            const parts = data.split(":");
+            if (parts.length >= 3 && parts[1] === userId) {
+                const mode = parts[2];
+                if (["ask", "accept-edits", "plan", "yolo"].includes(mode)) {
+                    setPermissionMode(userId, mode);
+                    await ctx.answerCbQuery(`✅ 已切换为 ${MODE_LABELS[mode]}`);
+                }
+            }
+        }
     });
     bot.on(message("text"), async (ctx) => {
         const chatId = String(ctx.chat.id);
@@ -321,6 +334,7 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
             return;
         }
         setActiveChatId("telegram", chatId);
+        setChatUser(chatId, userId);
         if (await commandHandler.dispatch(text, chatId, userId, "telegram", handleAIRequest)) {
             return;
         }
@@ -343,6 +357,7 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
         if (!accessControl.isAllowed(userId))
             return;
         setActiveChatId("telegram", chatId);
+        setChatUser(chatId, userId);
         const photos = ctx.message.photo;
         const largest = photos[photos.length - 1];
         let imagePath;

package/dist/telegram/message-sender.d.ts

@@ -8,4 +8,5 @@ export declare function sendImageReply(chatId: string, imagePath: string): Promi
  * 发送目录选择界面
  */
 export declare function sendDirectorySelection(chatId: string, currentDir: string, userId: string): Promise<void>;
+export declare function sendModeKeyboard(chatId: string, userId: string, currentMode: string): Promise<void>;
 export declare function startTypingLoop(chatId: string): () => void;

package/dist/telegram/message-sender.js

@@ -182,6 +182,20 @@ export async function sendDirectorySelection(chatId, currentDir, userId) {
         reply_markup: keyboard,
     });
 }
+export async function sendModeKeyboard(chatId, userId, currentMode) {
+    const bot = getBot();
+    const { MODE_LABELS } = await import("../permission-mode/types.js");
+    const modes = ["ask", "accept-edits", "plan", "yolo"];
+    const keyboard = {
+        inline_keyboard: [
+            modes.map((m) => ({
+                text: currentMode === m ? `✓ ${MODE_LABELS[m]}` : MODE_LABELS[m],
+                callback_data: `mode:${userId}:${m}`,
+            })),
+        ],
+    };
+    await bot.telegram.sendMessage(Number(chatId), `🔐 **权限模式** (当前: ${MODE_LABELS[currentMode] ?? currentMode})\n\n点击切换：`, { parse_mode: "Markdown", reply_markup: keyboard });
+}
 export function startTypingLoop(chatId) {
     const bot = getBot();
     const interval = setInterval(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.0.2-beta.3",
+  "version": "1.0.2",
   "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, Cursor)",
   "type": "module",
   "main": "dist/index.js",