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

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,19 +150,59 @@ 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);
-            return;
+        const MAX_SEND_RETRIES = 3;
+        for (let attempt = 1; attempt <= MAX_SEND_RETRIES; attempt++) {
+            try {
+                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;
+            }
         }
         const { messageId: msgId, cardId } = cardHandle;
         const stopTyping = startTypingLoop(chatId);
         const taskKey = `${userId}:${cardId}`;
+        let consecutiveStreamErrors = 0;
+        const MAX_STREAM_ERRORS = 5;
         const streamUpdate = (content, toolNote) => {
+            if (consecutiveStreamErrors >= MAX_STREAM_ERRORS)
+                return; // 停止尝试
             const note = buildProgressNote(toolNote);
-            streamContentUpdate(cardId, content, note).catch((e) => log.debug('Stream update failed (will retry on next update):', e?.message ?? e));
+            streamContentUpdate(cardId, content, note).then(() => {
+                consecutiveStreamErrors = 0;
+            }).catch((e) => {
+                consecutiveStreamErrors++;
+                if (consecutiveStreamErrors >= MAX_STREAM_ERRORS) {
+                    log.warn(`Stream update failed ${consecutiveStreamErrors} times consecutively, giving up: ${e?.message ?? e}`);
+                }
+                else {
+                    log.debug('Stream update failed (will retry on next update):', e?.message ?? e);
+                }
+            });
         };
         await runAITask({ config, sessionManager }, { userId, chatId, workDir, sessionId, convId, platform: 'feishu', taskKey }, prompt, toolAdapter, {
             throttleMs: CARDKIT_THROTTLE_MS,
@@ -105,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;
             }
         }
@@ -158,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

@@ -23,6 +23,8 @@ import { setupWeWorkHandlers } from "./wework/event-handler.js";
 import { sendProactiveTextReply as sendWeWorkTextReply } from "./wework/message-sender.js";
 import { initDingTalk, stopDingTalk, formatDingTalkInitError } from "./dingtalk/client.js";
 import { setupDingTalkHandlers } from "./dingtalk/event-handler.js";
+import { initWorkBuddy, stopWorkBuddy } from "./workbuddy/client.js";
+import { setupWorkBuddyHandlers } from "./workbuddy/event-handler.js";
 import { initAdapters, cleanupAdapters } from "./adapters/registry.js";
 import { SessionManager } from "./session/session-manager.js";
 import { loadActiveChats, getActiveChatId, flushActiveChats, } from "./shared/active-chats.js";
@@ -34,8 +36,8 @@ const require = createRequire(import.meta.url);
 const { version: APP_VERSION } = require("../package.json");
 const log = createLogger("Main");
 async function sendLifecycleNotification(platform, message) {
-    // DingTalk 不支持主动发消息（OpenAPI 需 robotCode 等，易报 robot 不存在），跳过启动/关闭通知
-    if (platform === "dingtalk")
+    // DingTalk 和 WorkBuddy 不支持主动发消息（OpenAPI 需 robotCode 等，易报 robot 不存在），跳过启动/关闭通知
+    if (platform === "dingtalk" || platform === "workbuddy")
         return;
     const telegramChatId = getActiveChatId("telegram");
     const feishuChatId = getActiveChatId("feishu");
@@ -174,6 +176,7 @@ export async function main() {
     let wechatHandle = null;
     let weworkHandle = null;
     let dingtalkHandle = null;
+    let workbuddyHandle = null;
     // Track successfully initialized platforms
     const successfulPlatforms = [];
     if (config.enabledPlatforms.includes("telegram")) {
@@ -237,6 +240,16 @@ export async function main() {
             log.error("Failed to initialize DingTalk:", formatDingTalkInitError(err));
         }
     }
+    if (config.enabledPlatforms.includes("workbuddy")) {
+        try {
+            workbuddyHandle = setupWorkBuddyHandlers(config, sessionManager);
+            await initWorkBuddy(config, workbuddyHandle.handleEvent);
+            successfulPlatforms.push("workbuddy");
+        }
+        catch (err) {
+            log.error("Failed to initialize WorkBuddy:", err);
+        }
+    }
     // Require at least one platform to start successfully
     if (successfulPlatforms.length === 0) {
         throw new Error("No platforms initialized successfully. Service cannot start.");
@@ -283,6 +296,8 @@ export async function main() {
         stopWeWork();
         dingtalkHandle?.stop();
         stopDingTalk();
+        workbuddyHandle?.stop();
+        stopWorkBuddy();
         sessionManager.destroy();
         cleanupAdapters();
         flushActiveChats();
@@ -291,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;
             }
         }
@@ -144,7 +145,20 @@ export function setupQQHandlers(config, sessionManager) {
             ? sessionManager.getSessionIdForConv(userId, convId, aiCommand)
             : undefined;
         const toolId = aiCommand;
-        const msgId = await sendThinkingMessage(chatId, replyToMessageId, toolId);
+        let msgId;
+        try {
+            msgId = await sendThinkingMessage(chatId, replyToMessageId, toolId);
+        }
+        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();
         const taskKey = `${userId}:${msgId}`;
         await runAITask({ config, sessionManager }, { userId, chatId, workDir, sessionId, convId, platform: "qq", taskKey }, prompt, toolAdapter, {

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/setup.js

@@ -940,8 +940,9 @@ const PLATFORM_LABELS = {
     wework: "企业微信",
     dingtalk: "钉钉",
     wechat: "微信（测试中）",
+    workbuddy: "WorkBuddy",
 };
-const ALL_PLATFORMS = ["telegram", "feishu", "qq", "wework", "dingtalk", "wechat"];
+const ALL_PLATFORMS = ["telegram", "feishu", "qq", "wework", "dingtalk", "wechat", "workbuddy"];
 /**
  * 启动时让用户选择要启用的平台（无论单通道还是多通道）
  * 显示全部 4 个平台，已配置的预选；若用户选择未配置的，引导运行 init

package/dist/shared/active-chats.d.ts

@@ -6,8 +6,8 @@ export interface DingTalkActiveTarget {
     updatedAt: number;
 }
 export declare function loadActiveChats(): void;
-export declare function getActiveChatId(platform: 'dingtalk' | 'feishu' | 'qq' | 'telegram' | 'wechat' | 'wework'): string | undefined;
-export declare function setActiveChatId(platform: 'dingtalk' | 'feishu' | 'qq' | 'telegram' | 'wechat' | 'wework', chatId: string): void;
+export declare function getActiveChatId(platform: 'dingtalk' | 'feishu' | 'qq' | 'telegram' | 'wechat' | 'wework' | 'workbuddy'): string | undefined;
+export declare function setActiveChatId(platform: 'dingtalk' | 'feishu' | 'qq' | 'telegram' | 'wechat' | 'wework' | 'workbuddy', chatId: string): void;
 export declare function getDingTalkActiveTarget(): DingTalkActiveTarget | undefined;
 export declare function setDingTalkActiveTarget(target: Omit<DingTalkActiveTarget, 'updatedAt'>): void;
 export declare function flushActiveChats(): void;

package/dist/shared/ai-task.js

@@ -247,7 +247,19 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
             startedAt: Date.now(),
             toolId: aiCommand,
         };
-        startRun();
+        try {
+            startRun();
+        }
+        catch (err) {
+            if (!settled) {
+                settled = true;
+                cleanup();
+                log.error(`[AITask] Synchronous error in startRun: ${err}`);
+                platformAdapter.sendError(`内部错误：${err instanceof Error ? err.message : String(err)}`).catch(() => { });
+                resolve();
+            }
+            return;
+        }
         platformAdapter.onTaskReady(taskState);
     });
 }

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)