@wu529778790/open-im 1.8.1-beta.2 → 1.8.1-beta.21

package/dist/shared/media-storage.js

@@ -131,6 +131,33 @@ export async function saveBase64Media(base64, extension, basenameHint) {
     return saveBufferMedia(Buffer.from(base64, "base64"), extension, basenameHint);
 }
 export async function downloadMediaFromUrl(url, options) {
+    // SSRF protection: validate URL before fetching
+    const BLOCKED_HOSTS = ['127.0.0.1', 'localhost', '0.0.0.0', '[::1]', '169.254.169.254'];
+    let parsedUrl;
+    try {
+        parsedUrl = new URL(url);
+    }
+    catch {
+        throw new Error(`Invalid URL: ${url}`);
+    }
+    const protocol = parsedUrl.protocol.toLowerCase();
+    if (protocol !== 'https:' && protocol !== 'http:') {
+        throw new Error(`Unsupported URL protocol: ${protocol}`);
+    }
+    const hostname = parsedUrl.hostname.toLowerCase();
+    for (const blocked of BLOCKED_HOSTS) {
+        if (hostname === blocked) {
+            throw new Error(`Blocked URL host: ${hostname}`);
+        }
+    }
+    // Block link-local and private IPs (e.g., 10.x.x.x, 172.16-31.x.x, 192.168.x.x)
+    const ipMatch = hostname.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+    if (ipMatch) {
+        const [, a, b] = ipMatch.map(Number);
+        if (a === 10 || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168) || a === 0) {
+            throw new Error(`Blocked private/internal IP: ${hostname}`);
+        }
+    }
     await mkdir(IMAGE_DIR, { recursive: true });
     const response = await fetch(url, { signal: AbortSignal.timeout(MEDIA_DOWNLOAD_TIMEOUT_MS) });
     if (!response.ok) {

package/dist/telegram/client.js

@@ -20,9 +20,31 @@ export async function initTelegram(config, setupHandlers) {
     setupHandlers(bot);
     const me = (await bot.telegram.getMe());
     botUsername = me.username;
-    bot.launch().catch((err) => {
-        log.error("Telegram polling error:", err);
-        process.exit(1);
+    const launchWithRetry = async (attempt = 1) => {
+        try {
+            await bot.launch();
+        }
+        catch (err) {
+            log.error("Telegram polling error:", err);
+            try {
+                bot.stop("Telegram polling error");
+            }
+            catch {
+                /* ignore */
+            }
+            const maxAttempts = 10;
+            const delayMs = Math.min(5000 * attempt, 60000);
+            if (attempt < maxAttempts) {
+                log.info(`Telegram reconnect in ${Math.round(delayMs / 1000)}s (attempt ${attempt}/${maxAttempts})`);
+                await new Promise((r) => setTimeout(r, delayMs));
+                return launchWithRetry(attempt + 1);
+            }
+            log.error("Telegram gave up reconnecting, skipping");
+            // 不再 exit(1)，让其他通道继续运行
+        }
+    };
+    void launchWithRetry().catch((err) => {
+        log.error("Telegram launchWithRetry failed fatally:", err);
     });
     log.info("Telegram bot launched");
 }

package/dist/telegram/event-handler.js

@@ -107,6 +107,12 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
         }
         catch (err) {
             log.error("Failed to send thinking message:", err);
+            try {
+                await sendTextReply(chatId, "启动 AI 处理失败，请重试。");
+            }
+            catch (err) {
+                log.warn('Failed to send startup error reply:', err);
+            }
             return;
         }
         const stopTyping = startTypingLoop(chatId);
@@ -176,7 +182,8 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
                     throttle.recordSuccess();
                     lastUpdateTime = Date.now();
                 }
-                catch {
+                catch (err) {
+                    log.debug('Stream update failed:', err);
                     throttle.recordError();
                 }
                 finally {
@@ -190,7 +197,7 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
                     }
                 }
             };
-            return (content, toolNote) => {
+            const wrapper = (content, toolNote) => {
                 if (content.startsWith("💭 **思考中...**")) {
                     return;
                 }
@@ -211,6 +218,17 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
                     performUpdate(content, toolNote);
                 }, Math.max(DEBOUNCE_MS, baseDelay));
             };
+            // flush 排队的 debounce 更新，防止 sendComplete 时仍有 streaming 更新在排队
+            wrapper.flush = async () => {
+                if (debounceTimer) {
+                    clearTimeout(debounceTimer);
+                    debounceTimer = null;
+                }
+                while (updateInProgress) {
+                    await new Promise((resolve) => setTimeout(resolve, 50));
+                }
+            };
+            return wrapper;
         };
         const streamUpdateWrapper = createStreamUpdateWrapper();
         await runAITask({ config, sessionManager }, {
@@ -228,12 +246,30 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
             },
             sendComplete: async (content, note) => {
                 throttle.reset();
-                try {
-                    await sendFinalMessages(chatId, msgId, content, note, toolId);
-                }
-                catch (err) {
-                    log.error("Failed to send complete message:", err);
-                    await updateMessage(chatId, msgId, content, "done", note, toolId);
+                // 先 flush 排队的 streaming 更新，防止它覆盖后续的 done 消息
+                await streamUpdateWrapper.flush?.();
+                const maxAttempts = 3;
+                for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                    try {
+                        await sendFinalMessages(chatId, msgId, content, note, toolId);
+                        return;
+                    }
+                    catch (err) {
+                        log.error(`Failed to send complete message (attempt ${attempt}/${maxAttempts}):`, err);
+                        if (attempt < maxAttempts) {
+                            await new Promise((r) => setTimeout(r, 2000 * attempt));
+                        }
+                        else {
+                            // 最终失败：尝试发送纯文本作为最后手段
+                            try {
+                                await sendTextReply(chatId, `⚠️ 消息更新失败（网络异常），以下是 AI 回复：\n\n${content.slice(0, 4000)}`);
+                            }
+                            catch (fallbackErr) {
+                                log.error("All send attempts failed:", fallbackErr);
+                                throw err;
+                            }
+                        }
+                    }
                 }
             },
             sendError: async (error) => {

package/dist/telegram/message-sender.js

@@ -9,6 +9,15 @@ import { MAX_TELEGRAM_MESSAGE_LENGTH } from "../constants.js";
 import { listDirectories, buildDirectoryKeyboard, } from "../commands/handler.js";
 const log = createLogger("TgSender");
 const lastSentByMsg = new Map();
+// Periodic cleanup of orphaned entries (entries not cleaned by done/error)
+const LAST_SENT_MAX_AGE_MS = 30 * 60 * 1000; // 30 minutes
+setInterval(() => {
+    // lastSentByMsg doesn't store timestamps, so clear all entries periodically
+    // since they are just dedup cache entries, clearing is safe
+    if (lastSentByMsg.size > 0) {
+        lastSentByMsg.clear();
+    }
+}, LAST_SENT_MAX_AGE_MS);
 const STATUS_ICONS = {
     thinking: "🔵",
     streaming: "🔵",
@@ -85,6 +94,10 @@ export async function updateMessage(chatId, messageId, content, status, note, to
         }
         else {
             log.error("Failed to update message:", err);
+            // 对 done/error 状态的更新失败必须 throw，否则消息永远卡在 streaming
+            if (status === "done" || status === "error") {
+                throw err;
+            }
         }
     }
     if (status === "done" || status === "error") {

package/dist/wechat/auth/qclaw-api.js

@@ -14,7 +14,7 @@ function nested(obj, ...keys) {
 export class QClawAPI {
     env;
     guid;
-    loginKey = 'm83qdao0AmE5';
+    loginKey = process.env.QCLAW_LOGIN_KEY || 'm83qdao0AmE5';
     jwtToken = '';
     userId = '';
     constructor(env, guid, jwtToken = '') {

package/dist/wechat/client.js

@@ -8,6 +8,7 @@ import { createLogger } from '../logger.js';
 const log = createLogger('WeChat');
 const TOKEN_FILE = 'wechat-token.json';
 const DEFAULT_WECHAT_WS_URL = 'wss://openclau-wechat.henryxiaoyang.workers.dev';
+const PONG_TIMEOUT_FACTOR = 3; // 3倍心跳间隔无响应则判定连接死亡
 // Global state
 let ws = null;
 let channelState = 'disconnected';
@@ -16,6 +17,9 @@ let heartbeatTimer = null;
 let reconnectAttempts = 0;
 let currentToken = null;
 let tokenStoragePath = null;
+let lastServerResponseTime = 0; // 上次收到服务端消息的时间
+let wsConfigRef = null; // 保存配置供心跳重连使用
+let isStopping = false; // 防止 stop 后重连定时器继续触发
 // Event handlers
 let messageHandler = null;
 let stateChangeHandler = null;
@@ -70,6 +74,7 @@ export async function initWeChat(config, eventHandler, onStateChange) {
     }
     messageHandler = eventHandler;
     stateChangeHandler = onStateChange ?? null;
+    isStopping = false;
     // Set up token storage path
     const baseDir = config.logDir ?? join(process.env.HOME ?? '', '.open-im');
     tokenStoragePath = join(baseDir, 'data');
@@ -92,15 +97,35 @@ export async function initWeChat(config, eventHandler, onStateChange) {
  * Connect to AGP WebSocket server
  */
 async function connectWebSocket(config) {
+    wsConfigRef = config;
     if (channelState === 'connecting') {
         log.warn('WebSocket connection already in progress');
         return;
     }
     updateState('connecting');
     return new Promise((resolve, reject) => {
+        let settled = false;
+        // Connection timeout to prevent promise from hanging forever
+        const connectionTimeout = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            const err = new Error('WeChat WebSocket connection timeout');
+            log.error(err.message);
+            updateState('error');
+            try {
+                ws?.close();
+            }
+            catch { /* ignore */ }
+            reject(err);
+        }, 30000);
         try {
             ws = new WebSocket(config.url);
             ws.on('open', () => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(connectionTimeout);
                 log.info('WeChat WebSocket connected');
                 reconnectAttempts = 0;
                 updateState('connected');
@@ -108,6 +133,7 @@ async function connectWebSocket(config) {
                 resolve();
             });
             ws.on('message', async (data) => {
+                lastServerResponseTime = Date.now();
                 try {
                     const envelope = JSON.parse(data.toString());
                     log.debug('Received AGP message:', envelope.method);
@@ -118,18 +144,33 @@ async function connectWebSocket(config) {
                 }
             });
             ws.on('error', (err) => {
+                if (settled) {
+                    // Late error after connection was established — just log it
+                    log.error('WeChat WebSocket error (after open):', err);
+                    return;
+                }
+                settled = true;
+                clearTimeout(connectionTimeout);
                 log.error('WeChat WebSocket error:', err);
                 updateState('error');
                 reject(err);
             });
             ws.on('close', () => {
+                clearTimeout(connectionTimeout);
                 log.info('WeChat WebSocket closed');
                 stopHeartbeat();
                 updateState('disconnected');
+                if (!settled) {
+                    settled = true;
+                    reject(new Error('WeChat WebSocket closed before open'));
+                    return;
+                }
                 scheduleReconnect(config);
             });
         }
         catch (err) {
+            settled = true;
+            clearTimeout(connectionTimeout);
             log.error('Error creating WebSocket connection:', err);
             updateState('error');
             reject(err);
@@ -190,11 +231,35 @@ function updateState(state) {
 }
 /**
  * Start heartbeat to keep connection alive
+ * 同时检测服务端是否响应，超时无响应则主动断开触发重连
  */
 function startHeartbeat(interval) {
     stopHeartbeat();
+    lastServerResponseTime = Date.now();
     heartbeatTimer = setInterval(() => {
         if (channelState === 'connected') {
+            // 检测连接是否已死：长时间未收到任何服务端响应
+            const elapsed = Date.now() - lastServerResponseTime;
+            const pongTimeout = interval * PONG_TIMEOUT_FACTOR;
+            if (lastServerResponseTime > 0 && elapsed > pongTimeout) {
+                log.warn(`No server response for ${Math.round(elapsed / 1000)}s, forcing reconnect`);
+                stopHeartbeat();
+                if (ws) {
+                    try {
+                        ws.removeAllListeners();
+                        ws.close();
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                    ws = null;
+                }
+                updateState('disconnected');
+                if (wsConfigRef) {
+                    scheduleReconnect(wsConfigRef);
+                }
+                return;
+            }
             sendAGPMessage('ping', { timestamp: Date.now() });
         }
     }, interval);
@@ -210,17 +275,28 @@ function stopHeartbeat() {
 }
 /**
  * Schedule reconnection attempt
+ * 超过 maxAttempts 后自动重置计数器继续重试，避免永久断连
  */
 function scheduleReconnect(config) {
+    if (isStopping)
+        return;
     const maxAttempts = config.maxReconnectAttempts ?? 10;
-    if (reconnectAttempts >= maxAttempts) {
-        log.error('Max reconnect attempts reached');
+    if (reconnectTimer) {
         return;
     }
-    const interval = config.reconnectInterval ?? 5000;
+    // 超过最大重试次数后重置计数器，降低频率继续重试
+    if (reconnectAttempts >= maxAttempts) {
+        log.warn(`Max reconnect attempts (${maxAttempts}) reached, resetting counter and retrying at lower frequency`);
+        reconnectAttempts = 0;
+    }
+    const baseInterval = config.reconnectInterval ?? 5000;
+    // 超过一半次数后逐渐增加间隔，最大 60 秒
+    const backoff = Math.min(baseInterval * Math.pow(1.5, Math.floor(reconnectAttempts / 3)), 60000);
+    const interval = Math.round(backoff);
     reconnectTimer = setTimeout(async () => {
+        reconnectTimer = null;
         reconnectAttempts++;
-        log.info(`Reconnecting... Attempt ${reconnectAttempts}/${maxAttempts}`);
+        log.info(`Reconnecting... Attempt ${reconnectAttempts}/${maxAttempts} (interval: ${interval}ms)`);
         try {
             await connectWebSocket(config);
         }
@@ -274,6 +350,7 @@ function saveToken() {
  * Stop WeChat client
  */
 export function stopWeChat() {
+    isStopping = true;
     stopHeartbeat();
     if (reconnectTimer) {
         clearTimeout(reconnectTimer);

package/dist/wechat/event-handler.js

@@ -53,7 +53,8 @@ export function setupWeChatHandlers(config, sessionManager) {
             }
             return parsed;
         }
-        catch {
+        catch (err) {
+            log.debug('Failed to parse WeChat incoming message JSON:', err);
             return null;
         }
     }
@@ -90,8 +91,8 @@ export function setupWeChatHandlers(config, sessionManager) {
                     text: contextText,
                 });
             }
-            catch {
-                // Fall through to metadata-only prompt.
+            catch (err) {
+                log.warn('Failed to download WeChat media, falling back to metadata-only prompt:', err);
             }
         }
         return buildMediaMetadataPrompt({
@@ -130,6 +131,12 @@ export function setupWeChatHandlers(config, sessionManager) {
         }
         catch (err) {
             log.error('Failed to send thinking message:', err);
+            try {
+                await sendTextReply(chatId, '启动 AI 处理失败，请重试。');
+            }
+            catch (err) {
+                log.warn('Failed to send startup error reply:', err);
+            }
             return;
         }
         const stopTyping = startTypingLoop(chatId);

package/dist/wework/client.js

@@ -13,6 +13,7 @@ import { createLogger } from '../logger.js';
 const log = createLogger('WeWork');
 const DEFAULT_WS_URL = 'wss://openws.work.weixin.qq.com';
 const HEARTBEAT_INTERVAL = 30000; // 30秒
+const PONG_TIMEOUT = HEARTBEAT_INTERVAL * 3; // 90秒无任何服务端响应则判定连接死亡
 const MAX_RECONNECT_ATTEMPTS = 100;
 // Global state
 let ws = null;
@@ -22,6 +23,7 @@ let heartbeatTimer = null;
 let reconnectAttempts = 0;
 let shouldReconnect = false;
 let isStopping = false;
+let lastServerResponseTime = 0; // 上次收到服务端消息的时间
 // Event handlers
 let messageHandler = null;
 let stateChangeHandler = null;
@@ -46,12 +48,10 @@ export function getConnectionState() {
  */
 export function sendProactiveMessage(chatId, content) {
     if (!ws || connectionState !== 'connected') {
-        log.error('Cannot send proactive message: WebSocket not connected');
-        return;
+        throw new Error('Cannot send proactive message: WebSocket not connected');
     }
     if (!chatId) {
-        log.error('Cannot send proactive message: chatId is required');
-        return;
+        throw new Error('Cannot send proactive message: chatId is required');
     }
     const message = {
         cmd: "aibot_send_msg" /* WeWorkCommand.AIBOT_SEND_MSG */,
@@ -77,12 +77,10 @@ export function sendProactiveMessage(chatId, content) {
  */
 export function sendWebSocketReply(reqId, body) {
     if (!ws || connectionState !== 'connected') {
-        log.error('Cannot send reply: WebSocket not connected');
-        return;
+        throw new Error('Cannot send reply: WebSocket not connected');
     }
     if (!reqId) {
-        log.error('Cannot send reply: req_id is required');
-        return;
+        throw new Error('Cannot send reply: req_id is required');
     }
     const message = {
         cmd: "aibot_respond_msg" /* WeWorkCommand.AIBOT_RESPOND_MSG */,
@@ -177,6 +175,7 @@ async function connectWebSocket() {
                 }
             });
             ws.on('message', async (data) => {
+                lastServerResponseTime = Date.now();
                 try {
                     const message = JSON.parse(data.toString());
                     await handleMessage(message);
@@ -330,11 +329,30 @@ function updateState(state) {
 }
 /**
  * Start heartbeat to keep connection alive
+ * 同时检测服务端是否响应，超时无响应则主动断开触发重连
  */
 function startHeartbeat() {
     stopHeartbeat();
+    lastServerResponseTime = Date.now();
     heartbeatTimer = setInterval(() => {
         if (connectionState === 'connected' && ws) {
+            // 检测连接是否已死：长时间未收到任何服务端响应
+            const elapsed = Date.now() - lastServerResponseTime;
+            if (lastServerResponseTime > 0 && elapsed > PONG_TIMEOUT) {
+                log.warn(`No server response for ${Math.round(elapsed / 1000)}s, forcing reconnect`);
+                stopHeartbeat();
+                try {
+                    ws.removeAllListeners();
+                    ws.close();
+                }
+                catch {
+                    /* ignore */
+                }
+                ws = null;
+                updateState('disconnected');
+                scheduleReconnect();
+                return;
+            }
             const pingMessage = {
                 cmd: "ping" /* WeWorkCommand.PING */,
                 headers: {
@@ -363,23 +381,27 @@ function stopHeartbeat() {
 }
 /**
  * Schedule reconnection attempt
+ * 超过 MAX_RECONNECT_ATTEMPTS 后自动重置计数器继续重试，避免永久断连
  */
 function scheduleReconnect() {
     if (isStopping || !shouldReconnect) {
         return;
     }
-    if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
-        log.error('Max reconnect attempts reached');
-        return;
-    }
-    const interval = 5000; // 5秒后重连
     if (reconnectTimer) {
         return;
     }
+    // 超过最大重试次数后重置计数器，降低频率继续重试
+    if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+        log.warn(`Max reconnect attempts (${MAX_RECONNECT_ATTEMPTS}) reached, resetting counter and retrying at lower frequency`);
+        reconnectAttempts = 0;
+    }
+    // 逐步增加间隔，5s → 7.5s → 11s → ... 最大 60s
+    const backoff = Math.min(5000 * Math.pow(1.5, Math.floor(reconnectAttempts / 5)), 60000);
+    const interval = Math.round(backoff);
     reconnectTimer = setTimeout(async () => {
         reconnectTimer = null;
         reconnectAttempts++;
-        log.info(`Reconnecting... Attempt ${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS}`);
+        log.info(`Reconnecting... Attempt ${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS} (interval: ${interval}ms)`);
         try {
             await connectWebSocket();
         }

package/dist/wework/event-handler.js

@@ -21,6 +21,8 @@ import { buildMediaContext } from '../shared/media-context.js';
 import { buildErrorNote, buildProgressNote } from '../shared/message-note.js';
 const log = createLogger('WeWorkHandler');
 const WEWORK_MEDIA_TIMEOUT_MS = 60_000;
+// Safety timeout: abort hung tasks before stream expires (5 min TTL → 4.5 min safety)
+const WEWORK_TASK_SAFETY_TIMEOUT_MS = 4.5 * 60 * 1000;
 async function saveWeWorkUrlMedia(payload, fallbackExtension) {
     if (!payload.url) {
         throw new Error("Missing WeWork media URL");
@@ -119,7 +121,8 @@ export async function buildMediaPrompt(data, kind) {
                     text: contextText,
                 });
             }
-            catch {
+            catch (err) {
+                log.warn('Failed to download WeWork image, falling back to URL reference:', err);
                 imageReference = `Remote image URL: ${imagePayload.url}`;
             }
         }
@@ -144,8 +147,8 @@ export async function buildMediaPrompt(data, kind) {
                 text: contextText,
             });
         }
-        catch {
-            // Fall back to metadata-only prompt.
+        catch (err) {
+            log.warn('Failed to download WeWork media, falling back to metadata-only prompt:', err);
         }
     }
     return buildMediaMetadataPrompt({
@@ -185,9 +188,40 @@ export function setupWeWorkHandlers(config, sessionManager) {
                 : undefined;
             log.info(`[handleAIRequest] Running ${aiCommand} for user ${userId}, sessionId=${sessionId ?? 'new'}`);
             const toolId = aiCommand;
-            const msgId = await sendThinkingMessage(chatId, replyToMessageId, toolId, reqId);
+            let msgId;
+            try {
+                msgId = await sendThinkingMessage(chatId, replyToMessageId, toolId, reqId);
+            }
+            catch (err) {
+                log.error('Failed to send thinking message:', err);
+                try {
+                    await sendTextReply(chatId, '启动 AI 处理失败，请重试。', reqId);
+                }
+                catch (err) {
+                    log.warn('Failed to send startup error reply:', err);
+                }
+                return;
+            }
             const stopTyping = startTypingLoop(chatId);
             const taskKey = `${userId}:${msgId}`;
+            // Safety timeout: abort hung tasks before stream expires, unblocking the queue
+            let safetyTimer = setTimeout(() => {
+                safetyTimer = null;
+                const state = runningTasks.get(taskKey);
+                if (state) {
+                    log.warn(`[SAFETY_TIMEOUT] Task ${taskKey} exceeded ${WEWORK_TASK_SAFETY_TIMEOUT_MS}ms, aborting`);
+                    state.handle.abort();
+                    runningTasks.delete(taskKey);
+                    stopTyping();
+                    sendTextReply(chatId, `AI 处理超时（${Math.round(WEWORK_TASK_SAFETY_TIMEOUT_MS / 1000)}s），已自动取消。请重试。`, reqId).catch(() => { });
+                }
+            }, WEWORK_TASK_SAFETY_TIMEOUT_MS);
+            const clearSafetyTimer = () => {
+                if (safetyTimer) {
+                    clearTimeout(safetyTimer);
+                    safetyTimer = null;
+                }
+            };
             await runAITask({ config, sessionManager }, { userId, chatId, workDir, sessionId, convId, platform: 'wework', taskKey }, prompt, toolAdapter, {
                 throttleMs: WEWORK_THROTTLE_MS,
                 streamUpdate: async (content, toolNote) => {
@@ -206,6 +240,7 @@ export function setupWeWorkHandlers(config, sessionManager) {
                     await updateMessage(chatId, msgId, `Error: ${error}`, 'error', buildErrorNote(), toolId, reqId);
                 },
                 extraCleanup: () => {
+                    clearSafetyTimer();
                     stopTyping();
                     runningTasks.delete(taskKey);
                 },