@wu529778790/open-im 1.8.1-beta.9 → 1.8.2

package/dist/dingtalk/message-sender.js

@@ -24,6 +24,19 @@ const FLOW_STATUS = {
 };
 let senderSettings = {};
 const streamStates = new Map();
+// Periodic cleanup of orphaned stream states (max 30 minutes)
+const STREAM_MAX_AGE_MS = 30 * 60 * 1000;
+setInterval(() => {
+    const now = Date.now();
+    for (const [id, state] of streamStates) {
+        // streamStates in DingTalk don't have createdAt, clean up by size
+        if (streamStates.size > 50) {
+            streamStates.delete(id);
+            log.info(`Cleaned up old DingTalk stream state: ${id}`);
+            break; // Clean one at a time to avoid blocking
+        }
+    }
+}, STREAM_MAX_AGE_MS);
 function generateMessageId() {
     return `${Date.now()}-${randomBytes(6).toString('hex')}`;
 }

package/dist/feishu/event-handler.js

@@ -17,6 +17,99 @@ import { buildSavedMediaPrompt } from '../shared/media-analysis-prompt.js';
 import { buildMediaContext } from '../shared/media-context.js';
 import { buildProgressNote } from '../shared/message-note.js';
 const log = createLogger('FeishuHandler');
+/**
+ * 从异常中提取飞书 API 错误码
+ */
+function extractFeishuErrorCode(err) {
+    const e = err;
+    if (e?.response?.data?.code)
+        return e.response.data.code;
+    if (e?.code)
+        return e.code;
+    return undefined;
+}
+/**
+ * 根据错误码判断是否为权限不足
+ */
+function isPermissionError(err) {
+    const code = extractFeishuErrorCode(err);
+    if (!code) {
+        // 非标准错误：检查 message 中是否包含权限关键词
+        const msg = err?.message ?? String(err);
+        return /permission|权限|scope|not authorized|no access|forbidden/i.test(msg);
+    }
+    // 飞书常见权限错误码
+    return [
+        99991400, // 权限不足
+        99991401, // 没有API权限
+        99991663, // 应用未获取 scope
+        99991672, // 应用未开通相关能力
+        99991670, // 应用未上架/未授权
+        99991668, // 应用可见性限制
+    ].includes(code);
+}
+/**
+ * 构建飞书权限配置指引消息
+ */
+function buildPermissionGuideMessage(err) {
+    const code = extractFeishuErrorCode(err);
+    const codeHint = code ? ` (错误码: ${code})` : '';
+    return [
+        '⚠️ **飞书应用权限不足，无法发送消息**' + codeHint,
+        '',
+        '请按以下步骤开通所需权限：',
+        '',
+        '**1. 进入飞书开放平台**',
+        '👉 https://open.feishu.cn/app',
+        '',
+        '**2. 找到你的应用，进入「权限管理」**',
+        '',
+        '**3. 开通以下权限（搜索权限名称添加）：**',
+        '• `im:message` — 获取与发送单聊、群组消息',
+        '• `im:message:send_as_bot` — 以应用身份发消息',
+        '• `im:resource` — 获取与上传图片或文件资源',
+        '• `im:chat` — 获取群组信息',
+        '',
+        '**4. 如需使用卡片打字机效果，还需开通：**',
+        '• `cardkit:card` — CardKit 卡片管理',
+        '',
+        '**5. 发布版本**',
+        '权限修改后需点击「创建版本」→「发布」，管理员审批后生效。',
+        '',
+        '📖 详细文档：https://open.feishu.cn/document/ukTMukTMukTM/ucTM5YjL3ETO04yNxkDN',
+    ].join('\n');
+}
+/**
+ * 发送权限错误提示，依次尝试：卡片 → 纯文本 → open_id
+ */
+async function sendPermissionFallback(chatId, guide) {
+    // 1. 先尝试 sendTextReply（发卡片消息）
+    try {
+        await sendTextReply(chatId, guide);
+        return;
+    }
+    catch (err) {
+        log.warn('Card-based reply failed, falling back to plain text:', err);
+    }
+    // 2. 降级为纯文本消息
+    try {
+        const client = (await import('./client.js')).getClient();
+        const plainGuide = guide.replace(/\*\*/g, '').replace(/`/g, '');
+        await client.im.message.create({
+            data: {
+                receive_id: chatId,
+                msg_type: 'text',
+                content: JSON.stringify({ text: plainGuide }),
+            },
+            params: { receive_id_type: 'chat_id' },
+        });
+        return;
+    }
+    catch (err) {
+        log.warn('Plain text reply also failed:', err);
+    }
+    log.error('All fallback methods failed to send permission guide');
+}
 async function downloadFeishuMessageResource(client, messageId, fileKey, type, options) {
     const targetPath = createMediaTargetPath(options?.fallbackExtension ?? 'bin', options?.basenameHint ?? fileKey);
     const response = await client.im.messageResource.get({
@@ -57,16 +150,38 @@ export function setupFeishuHandlers(config, sessionManager) {
         const toolId = aiCommand;
         // 使用 CardKit 打字机效果（80ms 节流，约 12 次/秒，比 patch 5 QPS 更流畅）
         let cardHandle;
-        try {
-            cardHandle = await sendThinkingCard(chatId, toolId);
-        }
-        catch (err) {
-            log.error('Failed to send thinking card:', err);
+        const MAX_SEND_RETRIES = 3;
+        for (let attempt = 1; attempt <= MAX_SEND_RETRIES; attempt++) {
             try {
-                await sendTextReply(chatId, '启动 AI 处理失败，请重试。');
+                cardHandle = await sendThinkingCard(chatId, toolId);
+                break;
+            }
+            catch (err) {
+                const isRetryable = err && typeof err === 'object' && 'code' in err &&
+                    (err.code === 'ETIMEDOUT' || err.code === 'ECONNRESET' || err.code === 'ECONNREFUSED');
+                if (isRetryable && attempt < MAX_SEND_RETRIES) {
+                    log.warn(`sendThinkingCard attempt ${attempt}/${MAX_SEND_RETRIES} failed (${err.code}), retrying...`);
+                    await new Promise((r) => setTimeout(r, 1000 * attempt));
+                    continue;
+                }
+                log.error(`Failed to send thinking card after ${attempt} attempts:`, err);
+                // 检测是否为飞书权限不足
+                if (isPermissionError(err)) {
+                    const guide = buildPermissionGuideMessage(err);
+                    await sendPermissionFallback(chatId, guide).catch((err) => {
+                        log.warn('Permission fallback send failed:', err);
+                    });
+                }
+                else {
+                    try {
+                        await sendTextReply(chatId, '启动 AI 处理失败，请重试。');
+                    }
+                    catch (err) {
+                        log.warn('Failed to send startup error reply:', err);
+                    }
+                }
+                return;
             }
-            catch { /* ignore */ }
-            return;
         }
         const { messageId: msgId, cardId } = cardHandle;
         const stopTyping = startTypingLoop(chatId);
@@ -123,7 +238,8 @@ export function setupFeishuHandlers(config, sessionManager) {
             try {
                 obj = JSON.parse(raw);
             }
-            catch {
+            catch (err) {
+                log.debug('Failed to parse action value as JSON:', err);
                 return null;
             }
         }
@@ -176,8 +292,8 @@ export function setupFeishuHandlers(config, sessionManager) {
             }
             actionData = parsed;
         }
-        catch {
-            /* ignore */
+        catch (err) {
+            log.debug('Failed to parse card action data:', err);
         }
         if (actionData?.action === 'stop' && actionData.card_id) {
             const cardId = actionData.card_id;

package/dist/index.js

@@ -306,6 +306,15 @@ export async function main() {
     };
     process.on("SIGINT", () => shutdown().catch(() => process.exit(1)));
     process.on("SIGTERM", () => shutdown().catch(() => process.exit(1)));
+    // Global error handlers to prevent unhandled crashes
+    process.on("unhandledRejection", (reason) => {
+        log.error("Unhandled Promise rejection:", reason);
+    });
+    process.on("uncaughtException", (err) => {
+        log.error("Uncaught exception (process will exit):", err);
+        closeLogger();
+        process.exit(1);
+    });
 }
 const isEntry = process.argv[1]?.replace(/\\/g, "/").endsWith("/index.js") ||
     process.argv[1]?.replace(/\\/g, "/").endsWith("/index.ts");

package/dist/manager-control.js

@@ -6,6 +6,10 @@ import { APP_HOME } from "./constants.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PID_FILE = join(APP_HOME, "open-im.pid");
 const READY_FILE = join(APP_HOME, "open-im.ready");
+function logError(prefix, err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[manager-control] ${prefix} ${msg}\n`);
+}
 function getManagerEntry() {
     const extension = extname(fileURLToPath(import.meta.url));
     if (extension === ".ts") {
@@ -106,6 +110,9 @@ export async function startManagerProcess(cwd) {
         env: process.env,
         windowsHide: process.platform === "win32",
     });
+    child.on("error", (err) => {
+        logError("Manager process spawn failed:", err);
+    });
     child.unref();
     if (!child.pid) {
         throw new Error("Failed to start manager process.");

package/dist/qq/client.js

@@ -17,6 +17,7 @@ let stopped = false;
 let seq = null;
 let sessionId = null;
 let reconnectAttempt = 0;
+let connecting = false; // 防止并发 connectWebSocket
 let currentConfig = null;
 let currentHandler = null;
 let tokenState = null;
@@ -143,103 +144,125 @@ function startHeartbeat(intervalMs) {
     heartbeatTimer = setInterval(() => {
         if (!ws || ws.readyState !== WebSocket.OPEN)
             return;
-        ws.send(JSON.stringify({ op: 1, d: seq }));
+        try {
+            ws.send(JSON.stringify({ op: 1, d: seq }));
+        }
+        catch (err) {
+            log.warn('QQ heartbeat send failed:', err);
+        }
     }, intervalMs);
 }
 async function connectWebSocket(config, handler) {
-    const gatewayUrl = await getGatewayUrl(config);
-    const token = await fetchAccessToken(config);
-    await new Promise((resolve, reject) => {
-        const socket = new WebSocket(gatewayUrl);
-        ws = socket;
-        let settled = false;
-        const settle = (fn) => {
-            if (settled)
-                return;
-            settled = true;
-            fn();
-        };
-        socket.on("open", () => {
-            log.info("QQ gateway connected");
-            reconnectAttempt = 0;
-        });
-        socket.on("message", async (raw) => {
-            try {
-                const payload = JSON.parse(raw.toString());
-                if (typeof payload.s === "number")
-                    seq = payload.s;
-                if (payload.op === 10) {
-                    const heartbeatInterval = Number(payload.d?.heartbeat_interval ?? 30000);
-                    startHeartbeat(heartbeatInterval);
-                    socket.send(JSON.stringify({
-                        op: sessionId ? 6 : 2,
-                        d: sessionId
-                            ? {
-                                token: `QQBot ${token}`,
-                                session_id: sessionId,
-                                seq,
-                            }
-                            : {
-                                token: `QQBot ${token}`,
-                                intents: INTENTS.GROUP_AND_C2C |
-                                    INTENTS.DIRECT_MESSAGE |
-                                    INTENTS.PUBLIC_GUILD_MESSAGES,
-                                properties: {
-                                    os: process.platform,
-                                    browser: "open-im",
-                                    device: "open-im",
-                                },
-                            },
-                    }));
-                    return;
-                }
-                if (payload.op === 0 && payload.t === "READY") {
-                    sessionId = String(payload.d?.session_id ?? "");
-                    settle(resolve);
+    // 防止并发连接
+    if (connecting) {
+        log.warn("QQ gateway connection already in progress");
+        return;
+    }
+    connecting = true;
+    try {
+        const gatewayUrl = await getGatewayUrl(config);
+        const token = await fetchAccessToken(config);
+        await new Promise((resolve, reject) => {
+            const socket = new WebSocket(gatewayUrl);
+            ws = socket;
+            let settled = false;
+            let readyTimeoutId = setTimeout(() => {
+                readyTimeoutId = null;
+                settle(() => reject(new Error("QQ gateway ready timeout")));
+            }, 15000);
+            const settle = (fn) => {
+                if (settled)
                     return;
+                settled = true;
+                if (readyTimeoutId) {
+                    clearTimeout(readyTimeoutId);
+                    readyTimeoutId = null;
                 }
-                if (payload.op === 0 && payload.t === "RESUMED") {
-                    settle(resolve);
-                    return;
+                fn();
+            };
+            socket.on("open", () => {
+                log.info("QQ gateway connected");
+                reconnectAttempt = 0;
+            });
+            socket.on("message", async (raw) => {
+                try {
+                    const payload = JSON.parse(raw.toString());
+                    if (typeof payload.s === "number")
+                        seq = payload.s;
+                    if (payload.op === 10) {
+                        const heartbeatInterval = Number(payload.d?.heartbeat_interval ?? 30000);
+                        startHeartbeat(heartbeatInterval);
+                        socket.send(JSON.stringify({
+                            op: sessionId ? 6 : 2,
+                            d: sessionId
+                                ? {
+                                    token: `QQBot ${token}`,
+                                    session_id: sessionId,
+                                    seq,
+                                }
+                                : {
+                                    token: `QQBot ${token}`,
+                                    intents: INTENTS.GROUP_AND_C2C |
+                                        INTENTS.DIRECT_MESSAGE |
+                                        INTENTS.PUBLIC_GUILD_MESSAGES,
+                                    properties: {
+                                        os: process.platform,
+                                        browser: "open-im",
+                                        device: "open-im",
+                                    },
+                                },
+                        }));
+                        return;
+                    }
+                    if (payload.op === 0 && payload.t === "READY") {
+                        sessionId = String(payload.d?.session_id ?? "");
+                        settle(resolve);
+                        return;
+                    }
+                    if (payload.op === 0 && payload.t === "RESUMED") {
+                        settle(resolve);
+                        return;
+                    }
+                    const event = normalizeInboundEvent(payload);
+                    if (event && (event.content || (event.attachments?.length ?? 0) > 0)) {
+                        await handler(event);
+                    }
                 }
-                const event = normalizeInboundEvent(payload);
-                if (event && (event.content || (event.attachments?.length ?? 0) > 0)) {
-                    await handler(event);
+                catch (error) {
+                    log.error("Failed to handle QQ gateway payload:", error);
                 }
-            }
-            catch (error) {
-                log.error("Failed to handle QQ gateway payload:", error);
-            }
-        });
-        socket.on("error", (error) => {
-            log.error("QQ gateway error:", error);
-            settle(() => reject(error));
-        });
-        socket.on("close", (code, reason) => {
-            clearTimers();
-            ws = null;
-            log.info(`QQ gateway closed: ${code} ${reason.toString()}`);
-            if (stopped)
-                return;
-            if (code === 4004 || code === 4006 || code === 4007 || code === 4009) {
-                tokenState = null;
-                sessionId = null;
-                seq = null;
-            }
-            const delay = RECONNECT_DELAYS_MS[Math.min(reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)];
-            reconnectAttempt += 1;
-            reconnectTimer = setTimeout(() => {
-                if (currentConfig && currentHandler) {
-                    connectWebSocket(currentConfig, currentHandler).catch((err) => {
-                        log.error("QQ reconnect failed:", err);
-                    });
+            });
+            socket.on("error", (error) => {
+                log.error("QQ gateway error:", error);
+                settle(() => reject(error));
+            });
+            socket.on("close", (code, reason) => {
+                settle(() => { }); // 清理 ready timeout
+                clearTimers();
+                ws = null;
+                log.info(`QQ gateway closed: ${code} ${reason.toString()}`);
+                if (stopped)
+                    return;
+                if (code === 4004 || code === 4006 || code === 4007 || code === 4009) {
+                    tokenState = null;
+                    sessionId = null;
+                    seq = null;
                 }
-            }, delay);
+                const delay = RECONNECT_DELAYS_MS[Math.min(reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)];
+                reconnectAttempt += 1;
+                reconnectTimer = setTimeout(() => {
+                    if (currentConfig && currentHandler) {
+                        connectWebSocket(currentConfig, currentHandler).catch((err) => {
+                            log.error("QQ reconnect failed:", err);
+                        });
+                    }
+                }, delay);
+            });
         });
-        setTimeout(() => {
-            settle(() => reject(new Error("QQ gateway ready timeout")));
-        }, 15000);
-    });
+    }
+    finally {
+        connecting = false;
+    }
 }
 export function getQQBot() {
     if (!client || !currentConfig) {

package/dist/qq/event-handler.js

@@ -62,7 +62,8 @@ async function buildAttachmentPrompt(event) {
                                 : "bin",
                 });
             }
-            catch {
+            catch (err) {
+                log.warn('Failed to download QQ media attachment:', err);
                 localPath = undefined;
             }
         }
@@ -153,7 +154,9 @@ export function setupQQHandlers(config, sessionManager) {
             try {
                 await sendTextReply(chatId, "启动 AI 处理失败，请重试。");
             }
-            catch { /* ignore */ }
+            catch (err) {
+                log.warn('Failed to send startup error reply:', err);
+            }
             return;
         }
         const stopTyping = startTypingLoop();

package/dist/qq/message-sender.js

@@ -7,6 +7,17 @@ import { buildDirectoryMessage } from "../shared/system-messages.js";
 const log = createLogger("QQSender");
 const MAX_QQ_MESSAGE_LENGTH = 1500;
 const pendingReplies = new Map();
+// Periodic cleanup of orphaned pending replies
+const PENDING_MAX_AGE_MS = 10 * 60 * 1000; // 10 minutes
+setInterval(() => {
+    const now = Date.now();
+    for (const [id, state] of pendingReplies) {
+        // pendingReplies don't have timestamps, but we can clear old ones based on size
+        if (pendingReplies.size > 100) {
+            pendingReplies.delete(id);
+        }
+    }
+}, PENDING_MAX_AGE_MS);
 function parseChatTarget(chatId) {
     if (chatId.startsWith("group:")) {
         return { kind: "group", id: chatId.slice("group:".length) };

package/dist/service-control.js

@@ -93,6 +93,10 @@ export function startBackgroundService(cwd) {
         env: process.env,
         windowsHide: process.platform === "win32",
     });
+    child.on("error", (err) => {
+        // Spawn failure (ENOENT etc.) — report via stderr since logger may not be initialized
+        process.stderr.write(`[service-control] Spawn failed: ${err.message}\n`);
+    });
     child.unref();
     if (!child.pid) {
         throw new Error("Failed to start background service.");

package/dist/session/session-manager.js

@@ -236,7 +236,17 @@ export class SessionManager {
         const resolved = resolveWorkDirInput(baseDir, targetDir);
         if (!existsSync(resolved))
             throw new Error(`目录不存在: \`${resolved}\``);
-        return realpath(resolved);
+        const real = await realpath(resolved);
+        // Block access to sensitive system directories
+        const blockedPrefixes = process.platform === 'win32'
+            ? ['C:\\Windows', 'C:\\Program Files', 'C:\\Program Files (x86)', 'C:\\ProgramData']
+            : ['/etc', '/proc', '/sys', '/dev', '/boot', '/root', '/sbin', '/usr/sbin'];
+        for (const prefix of blockedPrefixes) {
+            if (real.toLowerCase().startsWith(prefix.toLowerCase())) {
+                throw new Error(`不允许访问系统目录: \`${real}\``);
+            }
+        }
+        return real;
     }
     load(previousDefaultWorkDir) {
         try {

package/dist/shared/chat-user-map.js

@@ -4,6 +4,17 @@
  */
 const chatToUser = new Map();
 const chatToPlatform = new Map();
+// Periodic cleanup to prevent unbounded growth (keep last 1000 entries)
+const CHAT_MAP_MAX_SIZE = 1000;
+setInterval(() => {
+    if (chatToUser.size > CHAT_MAP_MAX_SIZE) {
+        const keysToDelete = [...chatToUser.keys()].slice(0, chatToUser.size - CHAT_MAP_MAX_SIZE);
+        for (const key of keysToDelete) {
+            chatToUser.delete(key);
+            chatToPlatform.delete(key);
+        }
+    }
+}, 60 * 60 * 1000); // Check every hour
 export function setChatUser(chatId, userId, platform) {
     chatToUser.set(chatId, userId);
     if (platform)

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

@@ -43,7 +43,9 @@ export async function initTelegram(config, setupHandlers) {
             // 不再 exit(1)，让其他通道继续运行
         }
     };
-    void launchWithRetry();
+    void launchWithRetry().catch((err) => {
+        log.error("Telegram launchWithRetry failed fatally:", err);
+    });
     log.info("Telegram bot launched");
 }
 export function stopTelegram() {