@wu529778790/open-im 0.3.12 → 1.0.0

package/dist/telegram/event-handler.js

@@ -1,25 +1,25 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-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 { 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';
-const log = createLogger('TgHandler');
+import { mkdir, writeFile } from "node:fs/promises";
+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 { 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 { TELEGRAM_THROTTLE_MS, IMAGE_DIR } from "../constants.js";
+import { setActiveChatId } from "../shared/active-chats.js";
+import { createLogger } from "../logger.js";
+const log = createLogger("TgHandler");
 // 动态节流器类 - 根据内容长度和更新频率调整间隔
 class DynamicThrottle {
     lastUpdate = 0;
     lastContentLength = 0;
     consecutiveErrors = 0;
-    baseInterval = THROTTLE_MS;
+    baseInterval = TELEGRAM_THROTTLE_MS;
     getNextDelay(contentLength) {
         const now = Date.now();
         const timeSinceLastUpdate = now - this.lastUpdate;
@@ -57,15 +57,17 @@ class DynamicThrottle {
 async function downloadTelegramPhoto(bot, fileId) {
     await mkdir(IMAGE_DIR, { recursive: true });
     const fileLink = await bot.telegram.getFileLink(fileId);
-    const res = await fetch(fileLink.href, { signal: AbortSignal.timeout(30000) });
+    const res = await fetch(fileLink.href, {
+        signal: AbortSignal.timeout(30000),
+    });
     const buffer = Buffer.from(await res.arrayBuffer());
-    const safeId = fileId.replace(/[^a-zA-Z0-9_-]/g, '_');
+    const safeId = fileId.replace(/[^a-zA-Z0-9_-]/g, "_");
     const imagePath = join(IMAGE_DIR, `${Date.now()}-${safeId.slice(-8)}.jpg`);
     await writeFile(imagePath, buffer);
     return imagePath;
 }
 export function setupTelegramHandlers(bot, config, sessionManager) {
-    const accessControl = new AccessControl(config.allowedUserIds);
+    const accessControl = new AccessControl(config.telegramAllowedUserIds);
     const requestQueue = new RequestQueue();
     const runningTasks = new Map();
     const stopTaskCleanup = startTaskCleanup(runningTasks);
@@ -77,7 +79,7 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
         sender: { sendTextReply },
         getRunningTasksSize: () => runningTasks.size,
     });
-    registerPermissionSender('telegram', {});
+    registerPermissionSender("telegram", {});
     async function handleAIRequest(userId, chatId, prompt, workDir, convId, _threadCtx, replyToMessageId) {
         // 在用户每次发送消息时就累加计数，确保提示能轮换显示
         const currentTurns = sessionManager.addTurns(userId, 1);
@@ -87,15 +89,17 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
             await sendTextReply(chatId, `未配置 AI 工具: ${config.aiCommand}`);
             return;
         }
-        const sessionId = convId ? sessionManager.getSessionIdForConv(userId, convId) : undefined;
-        log.info(`Running ${config.aiCommand} for user ${userId}, sessionId=${sessionId ?? 'new'}`);
+        const sessionId = convId
+            ? sessionManager.getSessionIdForConv(userId, convId)
+            : undefined;
+        log.info(`Running ${config.aiCommand} for user ${userId}, sessionId=${sessionId ?? "new"}`);
         const toolId = config.aiCommand;
         let msgId;
         try {
             msgId = await sendThinkingMessage(chatId, replyToMessageId, toolId);
         }
         catch (err) {
-            log.error('Failed to send thinking message:', err);
+            log.error("Failed to send thinking message:", err);
             return;
         }
         const stopTyping = startTypingLoop(chatId);
@@ -103,13 +107,13 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
         // 创建动态节流器
         const throttle = new DynamicThrottle();
         // 不保存思考内容，只显示最终结果
-        let savedThinkingText = '';
+        let savedThinkingText = "";
         let hasThinkingContent = false; // 始终为 false，不显示思考内容
         // 创建包装的流式更新函数（带串行化、智能跳过和防抖）
         const createStreamUpdateWrapper = () => {
             let lastUpdateTime = 0;
             let lastContentLength = 0;
-            let lastContent = '';
+            let lastContent = "";
             let pendingUpdate = null;
             let updateInProgress = false; // 串行化锁
             let scheduledContent = null; // 待更新内容
@@ -127,7 +131,7 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
                     }
                     // 如果有更新正在进行，等待它完成
                     while (updateInProgress) {
-                        await new Promise(resolve => setTimeout(resolve, 50));
+                        await new Promise((resolve) => setTimeout(resolve, 50));
                     }
                     // 重置状态，确保完成更新能立即执行
                     updateInProgress = false;
@@ -147,7 +151,7 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
                     if (hasThinkingContent && savedThinkingText) {
                         // 思考内容使用引用格式，用分隔线区分
                         const thinkingFormatted = `💭 思考过程：\n${savedThinkingText}`;
-                        const separator = '\n\n─────────\n\n';
+                        const separator = "\n\n─────────\n\n";
                         // 组合内容
                         const combined = thinkingFormatted + separator + content;
                         // 如果组合后超过预览长度，截取最后部分（但保留思考内容）
@@ -172,12 +176,13 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
                     }
                     else {
                         // 没有思考内容，直接显示（如果超过预览长度则截取）
-                        displayContent = content.length > STREAM_PREVIEW_LENGTH
-                            ? `...\n\n${content.slice(-STREAM_PREVIEW_LENGTH)}`
-                            : content;
+                        displayContent =
+                            content.length > STREAM_PREVIEW_LENGTH
+                                ? `...\n\n${content.slice(-STREAM_PREVIEW_LENGTH)}`
+                                : content;
                     }
-                    const note = toolNote ? '输出中...\n' + toolNote : '输出中...';
-                    await updateMessage(chatId, msgId, displayContent, 'streaming', note, toolId);
+                    const note = toolNote ? "输出中...\n" + toolNote : "输出中...";
+                    await updateMessage(chatId, msgId, displayContent, "streaming", note, toolId);
                     throttle.recordSuccess();
                     lastUpdateTime = Date.now();
                 }
@@ -201,7 +206,7 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
             let debounceTimer = null;
             return (content, toolNote) => {
                 // 检测是否是思考内容，如果则跳过不显示
-                if (content.startsWith('💭 **思考中...**')) {
+                if (content.startsWith("💭 **思考中...**")) {
                     // 不保存思考内容，直接返回，不触发更新
                     return;
                 }
@@ -232,12 +237,19 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
             };
         };
         const streamUpdateWrapper = createStreamUpdateWrapper();
-        await runAITask({ config, sessionManager }, { userId, chatId, workDir, sessionId, convId, platform: 'telegram', taskKey }, prompt, toolAdapter, {
-            throttleMs: THROTTLE_MS,
-            streamUpdate: streamUpdateWrapper,
-            onThinkingToText: (content) => {
-                // 从思考转到文本输出时，标记有思考内容
-                // 注意：此时不保存文本内容，因为后续会通过 streamUpdate 持续更新
+        await runAITask({ config, sessionManager }, {
+            userId,
+            chatId,
+            workDir,
+            sessionId,
+            convId,
+            platform: "telegram",
+            taskKey,
+        }, prompt, toolAdapter, {
+            throttleMs: TELEGRAM_THROTTLE_MS,
+            streamUpdate: (content, toolNote) => {
+                const note = toolNote ? "输出中...\n" + toolNote : "输出中...";
+                updateMessage(chatId, msgId, content, "streaming", note, toolId).catch(() => { });
             },
             sendComplete: async (content, note) => {
                 throttle.reset();
@@ -247,19 +259,19 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
                     await sendFinalMessages(chatId, msgId, content, note, toolId);
                 }
                 catch (err) {
-                    log.error('Failed to send complete message:', err);
+                    log.error("Failed to send complete message:", err);
                     // 如果发送失败，至少尝试更新状态
-                    await updateMessage(chatId, msgId, content, 'done', note, toolId);
+                    await updateMessage(chatId, msgId, content, "done", note, toolId);
                 }
             },
             sendError: async (error) => {
                 throttle.reset();
-                await updateMessage(chatId, msgId, `错误：${error}`, 'error', '执行失败', toolId);
+                await updateMessage(chatId, msgId, `错误：${error}`, "error", "执行失败", toolId);
             },
             extraCleanup: () => {
                 throttle.reset();
                 // 清理思考内容
-                savedThinkingText = '';
+                savedThinkingText = "";
                 hasThinkingContent = false;
                 stopTyping();
                 runningTasks.delete(taskKey);
@@ -270,37 +282,38 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
             sendImage: (path) => sendImageReply(chatId, path),
         });
     }
-    bot.on('callback_query', async (ctx) => {
+    bot.on("callback_query", async (ctx) => {
         const query = ctx.callbackQuery;
-        if (!('data' in query))
+        if (!("data" in query))
             return;
-        const userId = String(ctx.from?.id ?? '');
+        const userId = String(ctx.from?.id ?? "");
         const data = query.data;
-        if (data.startsWith('stop_')) {
-            const messageId = data.replace('stop_', '');
+        if (data.startsWith("stop_")) {
+            const messageId = data.replace("stop_", "");
             const taskKey = `${userId}:${messageId}`;
             const taskInfo = runningTasks.get(taskKey);
             if (taskInfo) {
                 runningTasks.delete(taskKey);
                 taskInfo.settle();
                 taskInfo.handle.abort();
-                const chatId = String(ctx.chat?.id ?? '');
-                await updateMessage(chatId, messageId, taskInfo.latestContent || '已停止', 'error', '⏹️ 已停止', config.aiCommand);
-                await ctx.answerCbQuery('已停止执行');
+                const chatId = String(ctx.chat?.id ?? "");
+                await updateMessage(chatId, messageId, taskInfo.latestContent || "已停止", "error", "⏹️ 已停止", config.aiCommand);
+                await ctx.answerCbQuery("已停止执行");
             }
             else {
-                await ctx.answerCbQuery('任务已完成或不存在');
+                await ctx.answerCbQuery("任务已完成或不存在");
             }
         }
-        else if (data.startsWith('perm_allow_') || data.startsWith('perm_deny_')) {
-            const isAllow = data.startsWith('perm_allow_');
-            const requestId = data.replace(/^perm_(allow|deny)_/, '');
-            const decision = isAllow ? 'allow' : 'deny';
+        else if (data.startsWith("perm_allow_") ||
+            data.startsWith("perm_deny_")) {
+            const isAllow = data.startsWith("perm_allow_");
+            const requestId = data.replace(/^perm_(allow|deny)_/, "");
+            const decision = isAllow ? "allow" : "deny";
             resolvePermissionById(requestId, decision);
-            await ctx.answerCbQuery(isAllow ? '✅ 已允许' : '❌ 已拒绝');
+            await ctx.answerCbQuery(isAllow ? "✅ 已允许" : "❌ 已拒绝");
         }
     });
-    bot.on(message('text'), async (ctx) => {
+    bot.on(message("text"), async (ctx) => {
         const chatId = String(ctx.chat.id);
         const userId = String(ctx.from.id);
         const messageId = String(ctx.message.message_id);
@@ -308,11 +321,11 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
         if (dedup.isDuplicate(`${chatId}:${messageId}`))
             return;
         if (!accessControl.isAllowed(userId)) {
-            await sendTextReply(chatId, '抱歉，您没有访问权限。\n您的 ID: ' + userId);
+            await sendTextReply(chatId, "抱歉，您没有访问权限。\n您的 ID: " + userId);
             return;
         }
-        setActiveChatId('telegram', chatId);
-        if (await commandHandler.dispatch(text, chatId, userId, 'telegram', handleAIRequest)) {
+        setActiveChatId("telegram", chatId);
+        if (await commandHandler.dispatch(text, chatId, userId, "telegram", handleAIRequest)) {
             return;
         }
         const workDir = sessionManager.getWorkDir(userId);
@@ -320,22 +333,22 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
         const enqueueResult = requestQueue.enqueue(userId, convId, text, async (prompt) => {
             await handleAIRequest(userId, chatId, prompt, workDir, convId, undefined, messageId);
         });
-        if (enqueueResult === 'rejected') {
-            await sendTextReply(chatId, '请求队列已满，请稍后再试。');
+        if (enqueueResult === "rejected") {
+            await sendTextReply(chatId, "请求队列已满，请稍后再试。");
         }
-        else if (enqueueResult === 'queued') {
-            await sendTextReply(chatId, '您的请求已排队等待。');
+        else if (enqueueResult === "queued") {
+            await sendTextReply(chatId, "您的请求已排队等待。");
         }
     });
-    bot.on(message('photo'), async (ctx) => {
+    bot.on(message("photo"), async (ctx) => {
         const chatId = String(ctx.chat.id);
         const userId = String(ctx.from.id);
-        const caption = ctx.message.caption?.trim() || '';
+        const caption = ctx.message.caption?.trim() || "";
         if (dedup.isDuplicate(`${chatId}:${ctx.message.message_id}`))
             return;
         if (!accessControl.isAllowed(userId))
             return;
-        setActiveChatId('telegram', chatId);
+        setActiveChatId("telegram", chatId);
         const photos = ctx.message.photo;
         const largest = photos[photos.length - 1];
         let imagePath;
@@ -343,8 +356,8 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
             imagePath = await downloadTelegramPhoto(bot, largest.file_id);
         }
         catch (err) {
-            log.error('Failed to download photo:', err);
-            await sendTextReply(chatId, '图片下载失败。');
+            log.error("Failed to download photo:", err);
+            await sendTextReply(chatId, "图片下载失败。");
             return;
         }
         const prompt = caption

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

@@ -1,4 +1,4 @@
-export type MessageStatus = 'thinking' | 'streaming' | 'done' | 'error';
+export type MessageStatus = "thinking" | "streaming" | "done" | "error";
 export declare function sendThinkingMessage(chatId: string, replyToMessageId?: string, 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/telegram/message-sender.js

@@ -1,27 +1,28 @@
-import { getBot } from './client.js';
-import { createReadStream } from 'node:fs';
-import { basename } from 'node:path';
-import { createLogger } from '../logger.js';
-import { splitLongContent, truncateText, preprocessMarkdownForTelegram } from '../shared/utils.js';
-import { MAX_TELEGRAM_MESSAGE_LENGTH } from '../constants.js';
-import { listDirectories, buildDirectoryKeyboard } from '../commands/handler.js';
-const log = createLogger('TgSender');
+import { getBot } from "./client.js";
+import { createReadStream } from "node:fs";
+import { basename } from "node:path";
+import { createLogger } from "../logger.js";
+import { splitLongContent, truncateText, preprocessMarkdownForTelegram, } from "../shared/utils.js";
+import { MAX_TELEGRAM_MESSAGE_LENGTH } from "../constants.js";
+import { listDirectories, buildDirectoryKeyboard, } from "../commands/handler.js";
+const log = createLogger("TgSender");
+const lastSentByMsg = new Map();
 const STATUS_ICONS = {
-    thinking: '🔵',
-    streaming: '🔵',
-    done: '🟢',
-    error: '🔴',
+    thinking: "🔵",
+    streaming: "🔵",
+    done: "🟢",
+    error: "🔴",
 };
 const TOOL_DISPLAY_NAMES = {
-    claude: 'claude-code',
-    codex: 'codex',
-    cursor: 'cursor',
+    claude: "claude-code",
+    codex: "codex",
+    cursor: "cursor",
 };
 function getToolTitle(toolId, status) {
     const name = TOOL_DISPLAY_NAMES[toolId] ?? toolId;
-    if (status === 'thinking')
+    if (status === "thinking")
         return `${name} - 思考中...`;
-    if (status === 'error')
+    if (status === "error")
         return `${name} - 错误`;
     return name;
 }
@@ -29,12 +30,12 @@ function getToolTitle(toolId, status) {
 const TG_MAX_LENGTH = 4096;
 // 预留给 header 和 note 的空间
 const RESERVED_LENGTH = 150;
-function formatMessage(content, status, note, toolId = 'claude') {
+function formatMessage(content, status, note, toolId = "claude") {
     const icon = STATUS_ICONS[status];
     const title = getToolTitle(toolId, status);
     // 在应用 Markdown 格式时，预处理内容以兼容 Telegram
     let processedContent = content;
-    if (status === 'done' || status === 'error') {
+    if (status === "done" || status === "error") {
         processedContent = preprocessMarkdownForTelegram(content);
     }
     // 计算可用内容长度（预留 header 和 note 空间）
@@ -50,7 +51,7 @@ function formatMessage(content, status, note, toolId = 'claude') {
     if (out.length > TG_MAX_LENGTH) {
         const keepLen = TG_MAX_LENGTH - 50;
         const tail = text.slice(text.length - keepLen);
-        const lineBreak = tail.indexOf('\n');
+        const lineBreak = tail.indexOf("\n");
         const clean = lineBreak > 0 && lineBreak < 200 ? tail.slice(lineBreak + 1) : tail;
         out = `${icon} ${title}\n\n...(前文已省略)...\n${clean}`;
         if (note)
@@ -60,127 +61,109 @@ function formatMessage(content, status, note, toolId = 'claude') {
 }
 function buildStopKeyboard(messageId) {
     return {
-        inline_keyboard: [[{ text: '⏹️ 停止', callback_data: `stop_${messageId}` }]],
+        inline_keyboard: [
+            [{ text: "⏹️ 停止", callback_data: `stop_${messageId}` }],
+        ],
     };
 }
-export async function sendThinkingMessage(chatId, replyToMessageId, toolId = 'claude') {
+export async function sendThinkingMessage(chatId, replyToMessageId, toolId = "claude") {
     const bot = getBot();
     const extra = {};
     if (replyToMessageId) {
-        extra.reply_parameters = {
-            message_id: Number(replyToMessageId),
-        };
+        extra.reply_parameters =
+            {
+                message_id: Number(replyToMessageId),
+            };
     }
-    // 初始消息使用纯文本，避免 Markdown 解析问题
-    const msg = await bot.telegram.sendMessage(Number(chatId), formatMessage('正在思考...', 'thinking', '请稍候', toolId), extra);
-    await bot.telegram.editMessageText(Number(chatId), msg.message_id, undefined, formatMessage('正在思考...', 'thinking', '请稍候', toolId), { reply_markup: buildStopKeyboard(msg.message_id) });
+    const text = formatMessage("正在思考...", "thinking", "请稍候", toolId);
+    const msg = await bot.telegram.sendMessage(Number(chatId), text, {
+        ...extra,
+        parse_mode: "Markdown",
+    });
+    await bot.telegram.editMessageReplyMarkup(Number(chatId), msg.message_id, undefined, buildStopKeyboard(msg.message_id));
     return String(msg.message_id);
 }
 // 检查错误是否可忽略（只忽略真正无害的错误）
 function isIgnorableError(err) {
-    if (err && typeof err === 'object' && 'message' in err) {
+    if (err && typeof err === "object" && "message" in err) {
         const msg = String(err.message);
         // 只忽略 "not modified" 类错误（内容没有变化）
-        return msg.includes('not modified') || msg.includes('message is not modified');
+        return (msg.includes("not modified") || msg.includes("message is not modified"));
     }
     return false;
 }
 // 提取重试延迟时间（秒）
 function extractRetryAfter(err) {
-    if (err && typeof err === 'object' && 'message' in err) {
+    if (err && typeof err === "object" && "message" in err) {
         const msg = String(err.message);
         const match = msg.match(/retry after (\d+)/);
         if (match)
             return parseInt(match[1], 10);
     }
-    if (err && typeof err === 'object' && 'parameters' in err) {
+    if (err && typeof err === "object" && "parameters" in err) {
         const params = err.parameters;
         if (params?.retry_after)
             return params.retry_after;
     }
     return null;
 }
-export async function updateMessage(chatId, messageId, content, status, note, toolId = 'claude') {
+export async function updateMessage(chatId, messageId, content, status, note, toolId = "claude") {
+    const formatted = formatMessage(content, status, note, toolId);
+    if (lastSentByMsg.get(messageId) === formatted)
+        return;
+    lastSentByMsg.set(messageId, formatted);
     const bot = getBot();
     const opts = {};
-    if (status === 'thinking' || status === 'streaming') {
+    if (status === "thinking" || status === "streaming") {
         opts.reply_markup = buildStopKeyboard(Number(messageId));
     }
-    else if (status === 'done' || status === 'error') {
-        // 完成或错误时，显式移除停止按钮（使用空的 inline_keyboard）
-        opts.reply_markup = { inline_keyboard: [] };
-        // 添加日志，帮助诊断
-        log.info(`Updating message to ${status} status (removing stop button) for ${chatId}:${messageId}, content length: ${content.length}`);
+    try {
+        await bot.telegram.editMessageText(Number(chatId), Number(messageId), undefined, formatted, { ...opts, parse_mode: "Markdown" });
     }
-    // 流式输出时使用纯文本，避免 Markdown 解析导致内容减少
-    // 完成时也暂时使用纯文本，避免 Markdown 解析错误
-    // TODO: 等待 Markdown 预处理稳定后再启用 Markdown
-    const shouldParseMarkdown = false; // 暂时禁用 Markdown 解析
-    let retries = 0;
-    const maxRetries = 2; // 减少重试次数，但增加等待时间
-    while (retries <= maxRetries) {
-        try {
-            await bot.telegram.editMessageText(Number(chatId), Number(messageId), undefined, formatMessage(content, status, note, toolId), { ...opts, parse_mode: shouldParseMarkdown ? 'Markdown' : undefined });
-            return;
+    catch (err) {
+        if (err &&
+            typeof err === "object" &&
+            "message" in err &&
+            String(err.message).includes("not modified")) {
+            /* ignore */
         }
-        catch (err) {
-            if (isIgnorableError(err)) {
-                // 忽略这些错误，不需要重试
-                return;
-            }
-            const retryAfter = extractRetryAfter(err);
-            if (retryAfter !== null && retries < maxRetries) {
-                // 429 错误，使用 Telegram 返回的实际等待时间
-                // 添加额外的缓冲时间（10%），确保不会立即再次触发限制
-                const delayMs = Math.ceil(retryAfter * 1000 * 1.1);
-                log.warn(`Rate limited, waiting ${delayMs}ms (${retryAfter}s + 10% buffer) before retry (${retries + 1}/${maxRetries})`);
-                await new Promise(resolve => setTimeout(resolve, delayMs));
-                retries++;
-                continue;
-            }
-            // 对于非 429 错误，使用指数退避
-            if (retries < maxRetries) {
-                const delayMs = Math.pow(2, retries) * 1000; // 1s, 2s, 4s
-                log.warn(`Temporary error, waiting ${delayMs}ms before retry (${retries + 1}/${maxRetries}):`, err);
-                await new Promise(resolve => setTimeout(resolve, delayMs));
-                retries++;
-                continue;
-            }
-            if (retries >= maxRetries) {
-                log.error('Failed to update message after retries:', err);
-            }
-            else {
-                log.error('Failed to update message:', err);
-            }
-            return;
+        else {
+            log.error("Failed to update message:", err);
         }
     }
+    if (status === "done" || status === "error") {
+        lastSentByMsg.delete(messageId);
+    }
 }
-export async function sendFinalMessages(chatId, messageId, fullContent, note, toolId = 'claude') {
+export async function sendFinalMessages(chatId, messageId, fullContent, note, toolId = "claude") {
     const parts = splitLongContent(fullContent, MAX_TELEGRAM_MESSAGE_LENGTH);
-    await updateMessage(chatId, messageId, parts[0], 'done', note, toolId);
+    await updateMessage(chatId, messageId, parts[0], "done", note, toolId);
     const bot = getBot();
     for (let i = 1; i < parts.length; i++) {
         try {
-            await bot.telegram.sendMessage(Number(chatId), formatMessage(parts[i], 'done', `(续 ${i + 1}/${parts.length}) ${note}`, toolId), { parse_mode: 'Markdown' });
+            await bot.telegram.sendMessage(Number(chatId), formatMessage(parts[i], "done", `(续 ${i + 1}/${parts.length}) ${note}`, toolId), { parse_mode: "Markdown" });
         }
         catch (err) {
-            log.error('Failed to send continuation:', err);
+            log.error("Failed to send continuation:", err);
         }
     }
 }
 export async function sendTextReply(chatId, text) {
     const bot = getBot();
     try {
-        await bot.telegram.sendMessage(Number(chatId), text, { parse_mode: 'Markdown' });
+        await bot.telegram.sendMessage(Number(chatId), text, {
+            parse_mode: "Markdown",
+        });
     }
     catch (err) {
-        log.error('Failed to send text:', err);
+        log.error("Failed to send text:", err);
     }
 }
 export async function sendImageReply(chatId, imagePath) {
     const bot = getBot();
-    await bot.telegram.sendPhoto(Number(chatId), { source: createReadStream(imagePath) });
+    await bot.telegram.sendPhoto(Number(chatId), {
+        source: createReadStream(imagePath),
+    });
 }
 /**
  * 发送目录选择界面
@@ -189,20 +172,20 @@ export async function sendDirectorySelection(chatId, currentDir, userId) {
     const bot = getBot();
     const directories = listDirectories(currentDir);
     if (directories.length === 0) {
-        await bot.telegram.sendMessage(Number(chatId), `📁 当前目录: \`${currentDir}\`\n\n没有可访问的子目录`, { parse_mode: 'Markdown' });
+        await bot.telegram.sendMessage(Number(chatId), `📁 当前目录: \`${currentDir}\`\n\n没有可访问的子目录`, { parse_mode: "Markdown" });
         return;
     }
     const keyboard = buildDirectoryKeyboard(directories, userId);
     const dirName = basename(currentDir) || currentDir;
     await bot.telegram.sendMessage(Number(chatId), `📁 当前目录: \`${dirName}\`\n\n选择要切换到的目录：`, {
-        parse_mode: 'Markdown',
+        parse_mode: "Markdown",
         reply_markup: keyboard,
     });
 }
 export function startTypingLoop(chatId) {
     const bot = getBot();
     const interval = setInterval(() => {
-        bot.telegram.sendChatAction(Number(chatId), 'typing').catch(() => { });
+        bot.telegram.sendChatAction(Number(chatId), "typing").catch(() => { });
     }, 4000);
     return () => clearInterval(interval);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "0.3.12",
+  "version": "1.0.0",
   "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, Cursor)",
   "type": "module",
   "main": "dist/index.js",
@@ -16,9 +16,9 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsx src/index.ts",
-    "run": "node dist/index.js",
     "start": "node dist/cli.js start",
     "stop": "node dist/cli.js stop",
+    "foreground": "node dist/cli.js dev",
     "setup": "node dist/index.js --setup-only",
     "test": "npm run build",
     "prepublishOnly": "npm run build"
@@ -41,7 +41,7 @@
     "url": "https://github.com/wu529778790/open-im/issues"
   },
   "dependencies": {
-    "https-proxy-agent": "^7.0.6",
+    "@larksuiteoapi/node-sdk": "^1.59.0",
     "prompts": "^2.4.2",
     "telegraf": "^4.16.3"
   },

package/.env.example

@@ -1,16 +0,0 @@
-# Telegram Bot Token (from @BotFather)
-TELEGRAM_BOT_TOKEN=
-
-# Allowed user IDs (comma-separated, empty = allow all in dev)
-ALLOWED_USER_IDS=
-
-# AI tool: claude | codex | cursor
-AI_COMMAND=claude
-
-# Claude CLI (when AI_COMMAND=claude)
-CLAUDE_CLI_PATH=claude
-CLAUDE_WORK_DIR=.
-CLAUDE_SKIP_PERMISSIONS=true
-CLAUDE_TIMEOUT_MS=600000
-CLAUDE_MODEL=
-ALLOWED_BASE_DIRS=