@wu529778790/open-im 0.2.12 → 0.3.1

package/dist/commands/handler.d.ts

@@ -5,6 +5,7 @@ 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>;
 }
 export interface CommandHandlerDeps {
     config: Config;
@@ -27,3 +28,24 @@ export declare class CommandHandler {
     private handleDeny;
     private getClaudeVersion;
 }
+/**
+ * 列出目录并返回目录信息
+ */
+export declare function listDirectories(basePath: string): {
+    name: string;
+    fullPath: string;
+    isParent: boolean;
+}[];
+/**
+ * 生成目录选择的按钮布局
+ */
+export declare function buildDirectoryKeyboard(directories: {
+    name: string;
+    fullPath: string;
+    isParent: boolean;
+}[], userId: string): {
+    inline_keyboard: Array<Array<{
+        text: string;
+        callback_data: string;
+    }>>;
+};

package/dist/commands/handler.js

@@ -1,6 +1,8 @@
 import { resolveLatestPermission, getPendingCount } from '../hook/permission-server.js';
 import { TERMINAL_ONLY_COMMANDS } from '../constants.js';
 import { execFile } from 'node:child_process';
+import { readdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 export class CommandHandler {
     deps;
     constructor(deps) {
@@ -81,8 +83,15 @@ export class CommandHandler {
         return true;
     }
     async handleCd(chatId, userId, dir) {
+        // 如果 dir 为空，显示目录选择界面
         if (!dir) {
-            await this.deps.sender.sendTextReply(chatId, `当前目录: ${this.deps.sessionManager.getWorkDir(userId)}\n使用 /cd <路径> 切换`);
+            const currentDir = this.deps.sessionManager.getWorkDir(userId);
+            if (this.deps.sender.sendDirectorySelection) {
+                await this.deps.sender.sendDirectorySelection(chatId, currentDir, userId);
+            }
+            else {
+                await this.deps.sender.sendTextReply(chatId, `当前目录: ${currentDir}\n使用 /cd <路径> 切换`);
+            }
             return true;
         }
         try {
@@ -125,3 +134,54 @@ export class CommandHandler {
         });
     }
 }
+/**
+ * 列出目录并返回目录信息
+ */
+export function listDirectories(basePath) {
+    const dirs = [];
+    try {
+        // 添加返回上级目录选项（如果不是根目录）
+        const parent = dirname(basePath);
+        if (parent !== basePath) {
+            dirs.push({ name: '🔙 返回上级', fullPath: parent, isParent: true });
+        }
+        // 读取子目录
+        const entries = readdirSync(basePath, { withFileTypes: true });
+        const subDirs = entries
+            .filter((entry) => entry.isDirectory())
+            .filter((entry) => !entry.name.startsWith('.')) // 过滤隐藏目录
+            .map((entry) => ({
+            name: entry.name,
+            fullPath: join(basePath, entry.name),
+            isParent: false,
+        }))
+            .sort((a, b) => a.name.localeCompare(b.name)); // 按名称排序
+        dirs.push(...subDirs);
+    }
+    catch {
+        // 忽略错误
+    }
+    return dirs;
+}
+/**
+ * 生成目录选择的按钮布局
+ */
+export function buildDirectoryKeyboard(directories, userId) {
+    const buttons = [];
+    // 每行 2 个按钮
+    for (let i = 0; i < directories.length; i += 2) {
+        const row = [];
+        row.push({
+            text: directories[i].name,
+            callback_data: `cd:${userId}:${encodeURIComponent(directories[i].fullPath)}`,
+        });
+        if (i + 1 < directories.length) {
+            row.push({
+                text: directories[i + 1].name,
+                callback_data: `cd:${userId}:${encodeURIComponent(directories[i + 1].fullPath)}`,
+            });
+        }
+        buttons.push(row);
+    }
+    return { inline_keyboard: buttons };
+}

package/dist/telegram/event-handler.js

@@ -14,6 +14,46 @@ import { 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;
+    getNextDelay(contentLength) {
+        const now = Date.now();
+        const timeSinceLastUpdate = now - this.lastUpdate;
+        // 如果最近有错误，增加延迟
+        if (this.consecutiveErrors > 0) {
+            const errorDelay = this.baseInterval * (1 + this.consecutiveErrors * 2);
+            this.lastUpdate = now;
+            return errorDelay;
+        }
+        // 内容增长较小时，适当增加延迟
+        const contentGrowth = contentLength - this.lastContentLength;
+        if (contentGrowth < 50 && timeSinceLastUpdate < 500) {
+            this.lastUpdate = now;
+            return 500; // 内容增长缓慢时，每 500ms 更新一次
+        }
+        // 内容增长较快，使用基础间隔
+        this.lastUpdate = now;
+        this.lastContentLength = contentLength;
+        return this.baseInterval;
+    }
+    recordError() {
+        this.consecutiveErrors++;
+        // 重置时间，确保下次使用延迟
+        this.lastUpdate = Date.now();
+    }
+    recordSuccess() {
+        this.consecutiveErrors = 0;
+    }
+    reset() {
+        this.lastUpdate = 0;
+        this.lastContentLength = 0;
+        this.consecutiveErrors = 0;
+    }
+}
 async function downloadTelegramPhoto(bot, fileId) {
     await mkdir(IMAGE_DIR, { recursive: true });
     const fileLink = await bot.telegram.getFileLink(fileId);
@@ -57,19 +97,151 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
         }
         const stopTyping = startTypingLoop(chatId);
         const taskKey = `${userId}:${msgId}`;
+        // 创建动态节流器
+        const throttle = new DynamicThrottle();
+        // 保存思考内容和状态
+        let savedThinkingText = '';
+        let hasThinkingContent = false; // 是否包含思考内容
+        // 创建包装的流式更新函数（带串行化、智能跳过和防抖）
+        const createStreamUpdateWrapper = () => {
+            let lastUpdateTime = 0;
+            let lastContentLength = 0;
+            let lastContent = '';
+            let pendingUpdate = null;
+            let updateInProgress = false; // 串行化锁
+            let scheduledContent = null; // 待更新内容
+            let scheduledToolNote;
+            // 流式输出时显示最后 N 个字符（增加到 1500 以提高流畅度）
+            const STREAM_PREVIEW_LENGTH = 1500;
+            // 执行更新（串行化）
+            const performUpdate = async (content, toolNote) => {
+                if (updateInProgress) {
+                    // 如果有更新正在进行，保存当前内容待更新
+                    scheduledContent = content;
+                    scheduledToolNote = toolNote;
+                    return;
+                }
+                updateInProgress = true;
+                try {
+                    let displayContent = content;
+                    // 如果有思考内容，将其格式化后添加到前面
+                    if (hasThinkingContent && savedThinkingText) {
+                        // 思考内容使用引用格式，用分隔线区分
+                        const thinkingFormatted = `💭 思考过程：\n${savedThinkingText}`;
+                        const separator = '\n\n─────────\n\n';
+                        // 组合内容
+                        const combined = thinkingFormatted + separator + content;
+                        // 如果组合后超过预览长度，截取最后部分（但保留思考内容）
+                        if (combined.length > STREAM_PREVIEW_LENGTH) {
+                            // 如果思考内容本身就很长，截取思考内容
+                            const maxThinkingLength = 800;
+                            const truncatedThinking = savedThinkingText.length > maxThinkingLength
+                                ? `...(已省略 ${savedThinkingText.length - maxThinkingLength} 字符)...\n\n${savedThinkingText.slice(-maxThinkingLength)}`
+                                : savedThinkingText;
+                            displayContent = `💭 思考过程：\n${truncatedThinking}\n\n─────────\n\n`;
+                            // 添加输出内容的最后部分
+                            if (content.length > 800) {
+                                displayContent += `...\n\n${content.slice(-800)}`;
+                            }
+                            else {
+                                displayContent += content;
+                            }
+                        }
+                        else {
+                            displayContent = combined;
+                        }
+                    }
+                    else {
+                        // 没有思考内容，直接显示（如果超过预览长度则截取）
+                        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);
+                    throttle.recordSuccess();
+                    lastUpdateTime = Date.now();
+                }
+                catch (err) {
+                    throttle.recordError();
+                }
+                finally {
+                    updateInProgress = false;
+                    // 如果有待更新的内容，立即更新
+                    if (scheduledContent !== null) {
+                        const nextContent = scheduledContent;
+                        const nextNote = scheduledToolNote;
+                        scheduledContent = null;
+                        scheduledToolNote = undefined;
+                        await performUpdate(nextContent, nextNote);
+                    }
+                }
+            };
+            // 防抖延迟（毫秒）- 降低到 150ms 提高响应速度
+            const DEBOUNCE_MS = 150;
+            let debounceTimer = null;
+            return (content, toolNote) => {
+                // 检测是否是思考内容
+                if (content.startsWith('💭 **思考中...**')) {
+                    // 保存思考内容（去掉前缀）
+                    savedThinkingText = content.replace('💭 **思考中...**\n\n', '');
+                    hasThinkingContent = true;
+                }
+                const now = Date.now();
+                const elapsed = now - lastUpdateTime;
+                // 智能跳过：内容增长小于 30 字符且距离上次更新不足 500ms（降低阈值，提高流畅度）
+                const contentGrowth = content.length - lastContentLength;
+                if (contentGrowth < 30 && elapsed < 500 && lastContentLength > 0) {
+                    // 跳过此次更新，但更新长度记录
+                    lastContentLength = content.length;
+                    lastContent = content;
+                    return;
+                }
+                // 更新记录
+                lastContentLength = content.length;
+                lastContent = content;
+                // 使用动态节流器计算基础延迟
+                const baseDelay = throttle.getNextDelay(content.length);
+                // 清除之前的防抖定时器
+                if (debounceTimer) {
+                    clearTimeout(debounceTimer);
+                }
+                // 设置防抖定时器
+                debounceTimer = setTimeout(() => {
+                    debounceTimer = null;
+                    performUpdate(content, toolNote);
+                }, Math.max(DEBOUNCE_MS, baseDelay));
+            };
+        };
+        const streamUpdateWrapper = createStreamUpdateWrapper();
         await runAITask({ config, sessionManager }, { userId, chatId, workDir, sessionId, convId, platform: 'telegram', taskKey }, prompt, toolAdapter, {
             throttleMs: THROTTLE_MS,
-            streamUpdate: (content, toolNote) => {
-                const note = toolNote ? '输出中...\n' + toolNote : '输出中...';
-                updateMessage(chatId, msgId, content, 'streaming', note, toolId).catch(() => { });
+            streamUpdate: streamUpdateWrapper,
+            onThinkingToText: (content) => {
+                // 从思考转到文本输出时，标记有思考内容
+                // 注意：此时不保存文本内容，因为后续会通过 streamUpdate 持续更新
             },
             sendComplete: async (content, note) => {
-                await sendFinalMessages(chatId, msgId, content, note, toolId);
+                throttle.reset();
+                // 完成时，如果有思考内容，将其包含在最终消息中
+                if (savedThinkingText && hasThinkingContent) {
+                    const thinkingFormatted = `💭 思考过程：\n${savedThinkingText}\n\n─────────\n\n`;
+                    const combined = thinkingFormatted + content;
+                    await sendFinalMessages(chatId, msgId, combined, note, toolId);
+                }
+                else {
+                    await sendFinalMessages(chatId, msgId, content, note, toolId);
+                }
             },
             sendError: async (error) => {
+                throttle.reset();
                 await updateMessage(chatId, msgId, `错误：${error}`, 'error', '执行失败', toolId);
             },
             extraCleanup: () => {
+                throttle.reset();
+                // 清理思考内容
+                savedThinkingText = '';
+                hasThinkingContent = false;
                 stopTyping();
                 runningTasks.delete(taskKey);
             },

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

@@ -4,4 +4,8 @@ export declare function updateMessage(chatId: string, messageId: string, content
 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>;
 export declare function sendImageReply(chatId: string, imagePath: string): Promise<void>;
+/**
+ * 发送目录选择界面
+ */
+export declare function sendDirectorySelection(chatId: string, currentDir: string, userId: string): Promise<void>;
 export declare function startTypingLoop(chatId: string): () => void;

package/dist/telegram/message-sender.js

@@ -1,8 +1,10 @@
 import { getBot } from './client.js';
 import { createReadStream } from 'node:fs';
+import { basename } from 'node:path';
 import { createLogger } from '../logger.js';
 import { splitLongContent, truncateText } from '../shared/utils.js';
 import { MAX_TELEGRAM_MESSAGE_LENGTH } from '../constants.js';
+import { listDirectories, buildDirectoryKeyboard } from '../commands/handler.js';
 const log = createLogger('TgSender');
 const STATUS_ICONS = {
     thinking: '🔵',
@@ -23,13 +25,32 @@ function getToolTitle(toolId, status) {
         return `${name} - 错误`;
     return name;
 }
+// Telegram 实际消息长度限制（4096 字符）
+const TG_MAX_LENGTH = 4096;
+// 预留给 header 和 note 的空间
+const RESERVED_LENGTH = 150;
 function formatMessage(content, status, note, toolId = 'claude') {
     const icon = STATUS_ICONS[status];
     const title = getToolTitle(toolId, status);
-    const text = truncateText(content, MAX_TELEGRAM_MESSAGE_LENGTH);
+    // 计算可用内容长度（预留 header 和 note 空间）
+    const headerLength = `${icon} ${title}\n\n`.length;
+    const noteLength = note ? `\n\n─────────\n${note}`.length : 0;
+    const maxContentLength = TG_MAX_LENGTH - headerLength - noteLength - RESERVED_LENGTH;
+    // 确保内容长度不超过限制
+    const text = truncateText(content, Math.max(100, maxContentLength));
     let out = `${icon} ${title}\n\n${text}`;
     if (note)
         out += `\n\n─────────\n${note}`;
+    // 最终安全检查：如果还是太长，强制截断
+    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 clean = lineBreak > 0 && lineBreak < 200 ? tail.slice(lineBreak + 1) : tail;
+        out = `${icon} ${title}\n\n...(前文已省略)...\n${clean}`;
+        if (note)
+            out += `\n\n─────────\n${note}`;
+    }
     return out;
 }
 function buildStopKeyboard(messageId) {
@@ -50,24 +71,83 @@ export async function sendThinkingMessage(chatId, replyToMessageId, toolId = 'cl
     await bot.telegram.editMessageText(Number(chatId), msg.message_id, undefined, formatMessage('正在思考...', 'thinking', '请稍候', toolId), { reply_markup: buildStopKeyboard(msg.message_id) });
     return String(msg.message_id);
 }
+// 检查错误是否可忽略
+function isIgnorableError(err) {
+    if (err && typeof err === 'object' && 'message' in err) {
+        const msg = String(err.message);
+        return (msg.includes('not modified') ||
+            msg.includes('MESSAGE_TOO_LONG') ||
+            msg.includes('can\'t parse entities') ||
+            msg.includes('message to edit not found') ||
+            msg.includes('message is not modified'));
+    }
+    return false;
+}
+// 提取重试延迟时间（秒）
+function extractRetryAfter(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) {
+        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') {
     const bot = getBot();
     const opts = {};
     if (status === 'thinking' || status === 'streaming') {
         opts.reply_markup = buildStopKeyboard(Number(messageId));
     }
+    else if (status === 'done' || status === 'error') {
+        // 完成或错误时，显式移除停止按钮
+        opts.reply_markup = {};
+    }
     // 流式输出时使用纯文本，避免 Markdown 解析导致内容减少
     // 只在完成时应用 Markdown 格式
     const shouldParseMarkdown = status === 'done' || status === 'error';
-    try {
-        await bot.telegram.editMessageText(Number(chatId), Number(messageId), undefined, formatMessage(content, status, note, toolId), { ...opts, parse_mode: shouldParseMarkdown ? 'Markdown' : undefined });
-    }
-    catch (err) {
-        if (err && typeof err === 'object' && 'message' in err && String(err.message).includes('not modified')) {
-            /* ignore */
+    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;
         }
-        else {
-            log.error('Failed to update message:', err);
+        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;
         }
     }
 }
@@ -97,6 +177,23 @@ export async function sendImageReply(chatId, imagePath) {
     const bot = getBot();
     await bot.telegram.sendPhoto(Number(chatId), { source: createReadStream(imagePath) });
 }
+/**
+ * 发送目录选择界面
+ */
+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' });
+        return;
+    }
+    const keyboard = buildDirectoryKeyboard(directories, userId);
+    const dirName = basename(currentDir) || currentDir;
+    await bot.telegram.sendMessage(Number(chatId), `📁 当前目录: \`${dirName}\`\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": "0.2.12",
+  "version": "0.3.1",
   "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, Cursor)",
   "type": "module",
   "main": "dist/index.js",