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

package/dist/config.d.ts

@@ -16,6 +16,7 @@ export interface Config {
     claudeSkipPermissions: boolean;
     claudeTimeoutMs: number;
     claudeModel?: string;
+    hookPort: number;
     logDir: string;
     logLevel: LogLevel;
     platforms: {

package/dist/config.js

@@ -87,6 +87,9 @@ export function loadConfig() {
     const claudeTimeoutMs = process.env.CLAUDE_TIMEOUT_MS !== undefined
         ? parseInt(process.env.CLAUDE_TIMEOUT_MS, 10) || 600000
         : file.claudeTimeoutMs ?? 600000;
+    const hookPort = process.env.HOOK_PORT !== undefined
+        ? parseInt(process.env.HOOK_PORT, 10) || 35801
+        : file.hookPort ?? 35801;
     // 6. 校验 Claude CLI
     if (aiCommand === 'claude') {
         if (isAbsolute(claudeCliPath) || claudeCliPath.includes('/') || claudeCliPath.includes('\\')) {
@@ -166,6 +169,7 @@ export function loadConfig() {
         claudeSkipPermissions,
         claudeTimeoutMs,
         claudeModel: process.env.CLAUDE_MODEL ?? file.claudeModel,
+        hookPort,
         logDir,
         logLevel,
         platforms,

package/dist/feishu/event-handler.js

@@ -2,13 +2,12 @@ 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, } from './message-sender.js';
-import { registerPermissionSender } from '../hook/permission-server.js';
+import { sendThinkingMessage, updateMessage, sendFinalMessages, sendTextReply, startTypingLoop, sendImageReply, createFeishuButtonCard, } from './message-sender.js';
+import { registerPermissionSender, resolvePermissionById } from '../hook/permission-server.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 { MessageDedup } from '../shared/message-dedup.js';
 import { THROTTLE_MS, IMAGE_DIR } from '../constants.js';
 import { setActiveChatId } from '../shared/active-chats.js';
 import { createLogger } from '../logger.js';
@@ -57,12 +56,53 @@ async function downloadFeishuImage(client, imageKey) {
     await writeFile(imagePath, buffer);
     return imagePath;
 }
+/**
+ * Send permission prompt card with interactive buttons
+ */
+async function sendPermissionCard(chatId, requestId, toolName, toolInput) {
+    const { getClient } = await import('./client.js');
+    const client = getClient();
+    // Format tool input for display
+    let formattedInput;
+    if (toolInput.length > 300) {
+        formattedInput = toolInput.slice(0, 300) + '...';
+    }
+    else {
+        formattedInput = toolInput;
+    }
+    const content = `**工具:** \`${toolName}\`
+
+**参数:**
+\`\`\`
+${formattedInput}
+\`\`\`
+
+**请求 ID:** \`${requestId.slice(-8)}\``;
+    const cardContent = createFeishuButtonCard('权限请求', content, [
+        { label: '✅ 允许', value: `allow_${requestId}`, type: 'primary' },
+        { label: '❌ 拒绝', value: `deny_${requestId}`, type: 'default' },
+    ]);
+    try {
+        await client.im.message.create({
+            data: {
+                receive_id: chatId,
+                msg_type: 'interactive',
+                content: cardContent,
+            },
+            params: { receive_id_type: 'chat_id' },
+        });
+        log.info(`Permission card sent for request ${requestId}`);
+    }
+    catch (err) {
+        log.error('Failed to send permission card:', err);
+        throw err;
+    }
+}
 export function setupFeishuHandlers(config, sessionManager) {
     const accessControl = new AccessControl(config.feishuAllowedUserIds);
     const requestQueue = new RequestQueue();
     const runningTasks = new Map();
     const stopTaskCleanup = startTaskCleanup(runningTasks);
-    const dedup = new MessageDedup();
     const commandHandler = new CommandHandler({
         config,
         sessionManager,
@@ -70,7 +110,7 @@ export function setupFeishuHandlers(config, sessionManager) {
         sender: { sendTextReply },
         getRunningTasksSize: () => runningTasks.size,
     });
-    registerPermissionSender('feishu', {});
+    registerPermissionSender('feishu', { sendTextReply, sendPermissionCard });
     async function handleAIRequest(userId, chatId, prompt, workDir, convId, _threadCtx, replyToMessageId) {
         log.info(`[AI_REQUEST] userId=${userId}, chatId=${chatId}, promptLength=${prompt.length}`);
         log.info(`[AI_REQUEST] Full prompt: "${prompt}"`);
@@ -135,6 +175,10 @@ export function setupFeishuHandlers(config, sessionManager) {
             //   "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;
@@ -142,6 +186,40 @@ export function setupFeishuHandlers(config, sessionManager) {
             // Handle message received events
             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;
+                            }
+                        }
+                    }
+                }
                 const message = event?.message;
                 if (!message) {
                     log.warn('No message data in event');
@@ -170,12 +248,6 @@ export function setupFeishuHandlers(config, sessionManager) {
                     return;
                 }
                 log.info(`Sender ID: ${senderId}`);
-                // Dedup check
-                const dedupKey = `${chatId}:${messageId}`;
-                if (dedup.isDuplicate(dedupKey)) {
-                    log.info(`Duplicate message detected: ${dedupKey}`);
-                    return;
-                }
                 // Access control check
                 if (!accessControl.isAllowed(senderId)) {
                     log.warn(`Access denied for sender: ${senderId}`);
@@ -220,14 +292,36 @@ export function setupFeishuHandlers(config, sessionManager) {
                     const post = content?.post;
                     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' && 'text' in section) {
-                                const tag = section?.tag;
+                            if (!section || typeof section !== 'object')
+                                continue;
+                            const tag = section?.tag;
+                            // Handle different content types
+                            if (tag === 'text' || tag === 'plain_text') {
                                 const t = section?.text ?? '';
-                                if (tag === 'text' || tag === 'plain_text') {
-                                    text += t;
+                                text += t;
+                            }
+                            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 ?? '';
+                                        }
+                                    }
+                                }
+                            }
+                            else {
+                                // Log unhandled tags for debugging
+                                log.info(`[MSG] Unhandled post tag: ${tag}, section:`, JSON.stringify(section).slice(0, 200));
                             }
                         }
                     }

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

@@ -1,4 +1,13 @@
 export type MessageStatus = 'thinking' | 'streaming' | 'done' | 'error';
+/**
+ * Create Feishu card with action buttons
+ * Used for permission prompts and other interactive requests
+ */
+export declare function createFeishuButtonCard(title: string, content: string, buttons: Array<{
+    label: string;
+    value: string;
+    type?: 'primary' | 'default';
+}>): string;
 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>;

package/dist/feishu/message-sender.js

@@ -61,6 +61,59 @@ function createFeishuCard(title, content, status, note) {
     };
     return JSON.stringify(card);
 }
+/**
+ * Create Feishu card with action buttons
+ * Used for permission prompts and other interactive requests
+ */
+export function createFeishuButtonCard(title, content, buttons) {
+    const elements = [];
+    // Main content
+    elements.push({
+        tag: 'div',
+        text: {
+            tag: 'lark_md',
+            content: content,
+        },
+    });
+    // Add separator
+    elements.push({ tag: 'hr' });
+    // Add action buttons
+    const actionGroups = [];
+    // Split buttons into rows (max 4 buttons per row in Feishu)
+    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: 'permission',
+                value: btn.value,
+            },
+        }));
+        actionGroups.push({
+            tag: 'action',
+            actions: row,
+        });
+    }
+    elements.push(...actionGroups);
+    const card = {
+        config: {
+            wide_screen_mode: true,
+        },
+        header: {
+            template: 'blue',
+            title: {
+                content: `🔐 ${title}`,
+                tag: 'plain_text',
+            },
+        },
+        elements,
+    };
+    return JSON.stringify(card);
+}
 async function getTenantAccessToken() {
     const client = getClient();
     const resp = await client.auth.tenantAccessToken.internal({

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

@@ -1,4 +1,36 @@
-export declare function resolveLatestPermission(_chatId: string, _decision: 'allow' | 'deny'): string | null;
-export declare function getPendingCount(_chatId: string): number;
-export declare function resolvePermissionById(_requestId: string, _decision: 'allow' | 'deny'): boolean;
-export declare function registerPermissionSender(_platform: string, _sender: unknown): void;
+/**
+ * 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.
+ */
+interface MessageSender {
+    sendTextReply(chatId: string, text: string): Promise<void>;
+    sendPermissionCard?(chatId: string, requestId: string, toolName: string, toolInput: string): Promise<void>;
+}
+/**
+ * Start the permission HTTP server
+ */
+export declare function startPermissionServer(port?: number): number;
+/**
+ * Stop the permission HTTP server
+ */
+export declare function stopPermissionServer(): void;
+/**
+ * Register the message sender for sending permission prompts
+ */
+export declare function registerPermissionSender(_platform: string, sender: MessageSender): void;
+/**
+ * Get the number of pending permission requests for a chat
+ */
+export declare function getPendingCount(chatId: string): number;
+/**
+ * Resolve the latest pending permission request for a chat
+ * Returns the requestId if found, null otherwise
+ */
+export declare function resolveLatestPermission(chatId: string, decision: 'allow' | 'deny'): string | null;
+/**
+ * Resolve a specific permission request by ID
+ */
+export declare function resolvePermissionById(requestId: string, decision: 'allow' | 'deny'): boolean;
+export {};

package/dist/hook/permission-server.js

@@ -1,12 +1,290 @@
-export function resolveLatestPermission(_chatId, _decision) {
-    return null;
+/**
+ * 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.
+ */
+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, toolName, toolInput } = data;
+            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');
+                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
+            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,7 @@ 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 { createRequire } from "node:module";
 const require = createRequire(import.meta.url);
 const { version: APP_VERSION } = require("../package.json");
@@ -46,6 +47,9 @@ export async function main() {
     initLogger(config.logDir, config.logLevel);
     loadActiveChats();
     initAdapters(config);
+    // Start permission server for tool approval
+    const actualPort = startPermissionServer(config.hookPort);
+    log.info(`Permission server listening on port ${actualPort}`);
     log.info("Starting open-im bridge...");
     log.info(`AI 工具: ${config.aiCommand}`);
     log.info(`工作目录: ${config.claudeWorkDir}`);
@@ -99,6 +103,7 @@ export async function main() {
         stopTelegram();
         feishuHandle?.stop();
         stopFeishu();
+        stopPermissionServer();
         sessionManager.destroy();
         cleanupAdapters();
         flushActiveChats();

package/dist/shared/ai-task.js

@@ -153,6 +153,7 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
             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/telegram/event-handler.js

@@ -9,7 +9,6 @@ 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 { MessageDedup } from "../shared/message-dedup.js";
 import { TELEGRAM_THROTTLE_MS, IMAGE_DIR } from "../constants.js";
 import { setActiveChatId } from "../shared/active-chats.js";
 import { createLogger } from "../logger.js";
@@ -71,7 +70,6 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
     const requestQueue = new RequestQueue();
     const runningTasks = new Map();
     const stopTaskCleanup = startTaskCleanup(runningTasks);
-    const dedup = new MessageDedup();
     const commandHandler = new CommandHandler({
         config,
         sessionManager,
@@ -79,7 +77,7 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
         sender: { sendTextReply },
         getRunningTasksSize: () => runningTasks.size,
     });
-    registerPermissionSender("telegram", {});
+    registerPermissionSender("telegram", { sendTextReply });
     async function handleAIRequest(userId, chatId, prompt, workDir, convId, _threadCtx, replyToMessageId) {
         // 在用户每次发送消息时就累加计数，确保提示能轮换显示
         const currentTurns = sessionManager.addTurns(userId, 1);
@@ -318,8 +316,6 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
         const userId = String(ctx.from.id);
         const messageId = String(ctx.message.message_id);
         let text = ctx.message.text.trim();
-        if (dedup.isDuplicate(`${chatId}:${messageId}`))
-            return;
         if (!accessControl.isAllowed(userId)) {
             await sendTextReply(chatId, "抱歉，您没有访问权限。\n您的 ID: " + userId);
             return;
@@ -344,8 +340,6 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
         const chatId = String(ctx.chat.id);
         const userId = String(ctx.from.id);
         const caption = ctx.message.caption?.trim() || "";
-        if (dedup.isDuplicate(`${chatId}:${ctx.message.message_id}`))
-            return;
         if (!accessControl.isAllowed(userId))
             return;
         setActiveChatId("telegram", chatId);

package/package.json

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