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

package/dist/hook/permission-server.js

@@ -1,12 +1,292 @@
-export function resolveLatestPermission(_chatId, _decision) {
-    return null;
+/**
+ * Permission Server - Handles tool permission requests from Claude CLI
+ *
+ * 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';
+const log = createLogger('PermissionServer');
+const PERMISSION_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes default timeout
+const DEFAULT_PORT = 35801;
+// Global state
+let server = null;
+let serverPort = DEFAULT_PORT;
+const pendingRequests = new Map();
+const requestsByChat = new Map();
+let messageSender = null;
+/**
+ * Start the permission HTTP server
+ */
+export function startPermissionServer(port = DEFAULT_PORT) {
+    if (server) {
+        log.warn('Permission server already running');
+        return serverPort;
+    }
+    serverPort = port;
+    server = createServer(handleRequest);
+    server.listen(port, () => {
+        log.info(`Permission server listening on port ${port}`);
+    });
+    server.on('error', (err) => {
+        log.error('Permission server error:', err);
+    });
+    // Cleanup expired permissions every minute
+    setInterval(() => {
+        cleanupExpiredPermissions();
+    }, 60 * 1000).unref();
+    return port;
 }
-export function getPendingCount(_chatId) {
-    return 0;
+/**
+ * Stop the permission HTTP server
+ */
+export function stopPermissionServer() {
+    if (server) {
+        server.close(() => {
+            log.info('Permission server stopped');
+        });
+        server = null;
+        // Reject all pending requests
+        for (const req of pendingRequests.values()) {
+            clearTimeout(req.timeout);
+            req.resolve(false);
+        }
+        pendingRequests.clear();
+        requestsByChat.clear();
+    }
 }
-export function resolvePermissionById(_requestId, _decision) {
-    return false;
+/**
+ * Register the message sender for sending permission prompts
+ */
+export function registerPermissionSender(_platform, sender) {
+    messageSender = sender;
+    log.info('Message sender registered for permission prompts');
 }
-export function registerPermissionSender(_platform, _sender) {
-    /* stub */
+/**
+ * Get the number of pending permission requests for a chat
+ */
+export function getPendingCount(chatId) {
+    const requests = requestsByChat.get(chatId);
+    return requests ? requests.length : 0;
+}
+/**
+ * Resolve the latest pending permission request for a chat
+ * Returns the requestId if found, null otherwise
+ */
+export function resolveLatestPermission(chatId, decision) {
+    const requests = requestsByChat.get(chatId);
+    if (!requests || requests.length === 0) {
+        return null;
+    }
+    // Get the oldest (first) pending request
+    const request = requests.shift();
+    if (requests.length === 0) {
+        requestsByChat.delete(chatId);
+    }
+    // Remove from global map
+    pendingRequests.delete(request.requestId);
+    // Clear timeout and resolve
+    clearTimeout(request.timeout);
+    request.resolve(decision === 'allow');
+    log.info(`Resolved permission ${request.requestId}: ${decision} for tool ${request.toolName}`);
+    return request.requestId;
+}
+/**
+ * Resolve a specific permission request by ID
+ */
+export function resolvePermissionById(requestId, decision) {
+    const request = pendingRequests.get(requestId);
+    if (!request) {
+        log.warn(`Permission request not found: ${requestId}`);
+        return false;
+    }
+    // Remove from chat's list
+    const chatRequests = requestsByChat.get(request.chatId);
+    if (chatRequests) {
+        const index = chatRequests.findIndex(r => r.requestId === requestId);
+        if (index !== -1) {
+            chatRequests.splice(index, 1);
+        }
+        if (chatRequests.length === 0) {
+            requestsByChat.delete(request.chatId);
+        }
+    }
+    // Remove from global map
+    pendingRequests.delete(requestId);
+    // Clear timeout and resolve
+    clearTimeout(request.timeout);
+    request.resolve(decision === 'allow');
+    log.info(`Resolved permission ${requestId}: ${decision} for tool ${request.toolName}`);
+    return true;
+}
+/**
+ * Handle incoming HTTP requests from Claude CLI
+ */
+function handleRequest(req, res) {
+    const url = new URL(req.url || '', `http://${req.headers.host}`);
+    log.debug(`Permission request: ${req.method} ${url.pathname}`);
+    if (url.pathname === '/permission' && req.method === 'POST') {
+        handlePermissionRequest(req, res);
+    }
+    else if (url.pathname === '/health' && req.method === 'GET') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ status: 'ok', port: serverPort }));
+    }
+    else {
+        res.writeHead(404);
+        res.end('Not found');
+    }
+}
+/**
+ * Handle a permission request from Claude CLI
+ */
+function handlePermissionRequest(req, res) {
+    let body = '';
+    req.on('data', (chunk) => {
+        body += chunk.toString();
+    });
+    req.on('end', async () => {
+        try {
+            const data = JSON.parse(body);
+            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;
+            }
+            if (!chatId) {
+                log.warn('No chatId, auto-allowing permission');
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ allowed: true }));
+                return;
+            }
+            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;
+            }
+            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;
+            }
+            res.writeHead(202, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ status: 'pending' }));
+            // Create permission request
+            const permissionRequest = {
+                requestId,
+                chatId,
+                toolName,
+                toolInput: formatToolInput(toolInput),
+                timestamp: Date.now(),
+                resolve: null, // Will set below
+                timeout: null,
+            };
+            // Create promise for waiting for user response
+            const permissionPromise = new Promise((resolve) => {
+                permissionRequest.resolve = resolve;
+            });
+            // Set timeout
+            permissionRequest.timeout = setTimeout(() => {
+                log.info(`Permission request ${requestId} timed out`);
+                resolvePermissionById(requestId, 'deny');
+            }, PERMISSION_TIMEOUT_MS);
+            // Store request
+            pendingRequests.set(requestId, permissionRequest);
+            // Add to chat's list
+            let chatRequests = requestsByChat.get(chatId);
+            if (!chatRequests) {
+                chatRequests = [];
+                requestsByChat.set(chatId, chatRequests);
+            }
+            chatRequests.push(permissionRequest);
+            // Send permission prompt to user
+            await sendPermissionPrompt(permissionRequest);
+            // Wait for user response
+            const allowed = await permissionPromise;
+            log.info(`Permission ${requestId} for ${toolName}: ${allowed ? 'ALLOWED' : 'DENIED'}`);
+        }
+        catch (err) {
+            log.error('Error handling permission request:', err);
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Internal server error' }));
+        }
+    });
+}
+/**
+ * Send permission prompt to the user
+ */
+async function sendPermissionPrompt(request) {
+    if (!messageSender) {
+        log.warn('No message sender registered, cannot send permission prompt');
+        return;
+    }
+    // Try to use interactive button card if available (Feishu)
+    if (messageSender.sendPermissionCard) {
+        try {
+            await messageSender.sendPermissionCard(request.chatId, request.requestId, request.toolName, request.toolInput);
+            return;
+        }
+        catch (err) {
+            log.debug('Failed to send permission card, falling back to text:', err);
+        }
+    }
+    // Fallback to text-based prompt
+    const prompt = `🔐 **权限请求**
+
+工具: \`${request.toolName}\`
+
+参数:
+\`\`\`
+${request.toolInput}
+\`\`\`
+
+回复 \`/allow\` 允许，\`/deny\` 拒绝
+
+请求 ID: ${request.requestId}`;
+    try {
+        await messageSender.sendTextReply(request.chatId, prompt);
+    }
+    catch (err) {
+        log.error('Failed to send permission prompt:', err);
+    }
+}
+/**
+ * Format tool input for display
+ */
+function formatToolInput(toolInput) {
+    if (typeof toolInput === 'string') {
+        return toolInput;
+    }
+    if (typeof toolInput === 'object' && toolInput !== null) {
+        try {
+            const str = JSON.stringify(toolInput, null, 2);
+            return str.length > 500 ? str.slice(0, 500) + '...' : str;
+        }
+        catch {
+            return String(toolInput);
+        }
+    }
+    return String(toolInput);
+}
+/**
+ * Clean up expired permission requests
+ */
+function cleanupExpiredPermissions() {
+    const now = Date.now();
+    for (const [requestId, request] of pendingRequests.entries()) {
+        if (now - request.timestamp > PERMISSION_TIMEOUT_MS) {
+            log.info(`Cleaning up expired permission: ${requestId}`);
+            resolvePermissionById(requestId, 'deny');
+        }
+    }
 }

package/dist/index.js

@@ -16,6 +16,8 @@ import { SessionManager } from "./session/session-manager.js";
 import { loadActiveChats, getActiveChatId, flushActiveChats, } from "./shared/active-chats.js";
 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");
@@ -45,10 +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;
@@ -68,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
@@ -99,6 +109,7 @@ export async function main() {
         stopTelegram();
         feishuHandle?.stop();
         stopFeishu();
+        stopPermissionServer();
         sessionManager.destroy();
         cleanupAdapters();
         flushActiveChats();

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,10 +163,12 @@ 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,
+            hookPort: config.hookPort,
         });
         taskState = { handle, latestContent: '', settle, startedAt: Date.now() };
         platformAdapter.onTaskReady(taskState);

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,10 +77,10 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
         config,
         sessionManager,
         requestQueue,
-        sender: { sendTextReply },
+        sender: { sendTextReply, sendDirectorySelection, sendModeKeyboard },
         getRunningTasksSize: () => runningTasks.size,
     });
-    registerPermissionSender("telegram", {});
+    registerPermissionSender("telegram", { sendTextReply });
     async function handleAIRequest(userId, chatId, prompt, workDir, convId, _threadCtx, replyToMessageId) {
         // 在用户每次发送消息时就累加计数，确保提示能轮换显示
         const currentTurns = sessionManager.addTurns(userId, 1);
@@ -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.2",
+  "version": "1.0.2",
   "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, Cursor)",
   "type": "module",
   "main": "dist/index.js",