@wu529778790/open-im 1.8.1-beta.8 → 1.8.1

package/dist/adapters/claude-sdk-adapter.js

@@ -103,6 +103,7 @@ export class ClaudeSDKAdapter {
         const abortController = new AbortController();
         let streamClosed = false;
         let actualSessionId;
+        let pendingTempId; // 记录临时 ID，用于 abort 时清理
         let runSettled = false;
         let timeoutId = null;
         const timeoutMs = options?.timeoutMs ?? 600_000;
@@ -139,7 +140,10 @@ export class ClaudeSDKAdapter {
                 log.info(`[V2] Session: ${sessionId ?? 'new'}, prompt="${prompt.slice(0, 50)}..."`);
                 log.info(`[V2] model param=${String(options?.model ?? '')} baseUrl=${process.env.ANTHROPIC_BASE_URL ?? '(default)'}`);
                 // 获取或创建会话
-                const { session } = await getOrCreateSession(sessionId, workDir, options?.model, permissionMode);
+                const { session, sessionId: returnedId } = await getOrCreateSession(sessionId, workDir, options?.model, permissionMode);
+                if (returnedId.startsWith('pending-')) {
+                    pendingTempId = returnedId;
+                }
                 // 发送用户消息
                 await session.send(prompt);
                 // 获取响应流
@@ -263,6 +267,12 @@ export class ClaudeSDKAdapter {
                 if (abortController.signal.aborted) {
                     log.info('Session run aborted');
                     clearRunTimeout();
+                    // 清理 pending tempId（abort 可能在 init 消息之前发生）
+                    const idToClean = actualSessionId ?? pendingTempId;
+                    if (idToClean?.startsWith('pending-')) {
+                        activeSessions.delete(idToClean);
+                        log.info(`Cleaned up pending session: ${idToClean}`);
+                    }
                     return;
                 }
                 runSettled = true;
@@ -273,6 +283,12 @@ export class ClaudeSDKAdapter {
                 if (errorObj.stack) {
                     log.error(`Error stack: ${errorObj.stack}`);
                 }
+                // 清理 pending tempId（session 在获取真实 ID 前就失败了）
+                const errIdToClean = actualSessionId ?? pendingTempId;
+                if (errIdToClean?.startsWith('pending-')) {
+                    activeSessions.delete(errIdToClean);
+                    log.info(`Cleaned up pending session after error: ${errIdToClean}`);
+                }
                 callbacks.onError(msg);
             }
         };

package/dist/config-web.js

@@ -117,6 +117,7 @@ export function getHealthPlatformSnapshot(file, env = process.env) {
     const fileQQ = file.platforms?.qq;
     const fileWework = file.platforms?.wework;
     const fileDingtalk = file.platforms?.dingtalk;
+    const fileWorkbuddy = file.platforms?.workbuddy;
     const telegramBotToken = env.TELEGRAM_BOT_TOKEN ?? fileTelegram?.botToken ?? file.telegramBotToken;
     const feishuAppId = env.FEISHU_APP_ID ?? fileFeishu?.appId ?? file.feishuAppId;
     const feishuAppSecret = env.FEISHU_APP_SECRET ?? fileFeishu?.appSecret ?? file.feishuAppSecret;
@@ -126,6 +127,9 @@ export function getHealthPlatformSnapshot(file, env = process.env) {
     const weworkSecret = env.WEWORK_SECRET ?? fileWework?.secret;
     const dingtalkClientId = env.DINGTALK_CLIENT_ID ?? fileDingtalk?.clientId;
     const dingtalkClientSecret = env.DINGTALK_CLIENT_SECRET ?? fileDingtalk?.clientSecret;
+    const workbuddyAccessToken = fileWorkbuddy?.accessToken;
+    const workbuddyRefreshToken = fileWorkbuddy?.refreshToken;
+    const workbuddyUserId = fileWorkbuddy?.userId;
     return {
         telegram: {
             configured: !!telegramBotToken,
@@ -157,6 +161,12 @@ export function getHealthPlatformSnapshot(file, env = process.env) {
             healthy: !!(dingtalkClientId && dingtalkClientSecret),
             message: dingtalkClientId && dingtalkClientSecret ? "Client ID and Secret configured" : "Missing credentials",
         },
+        workbuddy: {
+            configured: !!(workbuddyAccessToken && workbuddyRefreshToken && workbuddyUserId),
+            enabled: !!(workbuddyAccessToken && workbuddyRefreshToken && workbuddyUserId) && fileWorkbuddy?.enabled !== false,
+            healthy: !!(workbuddyAccessToken && workbuddyRefreshToken && workbuddyUserId),
+            message: workbuddyAccessToken && workbuddyRefreshToken && workbuddyUserId ? "OAuth credentials configured" : "Missing credentials",
+        },
     };
 }
 function splitCsv(value) {
@@ -231,6 +241,15 @@ function buildInitialPayload(file) {
                 cardTemplateId: file.platforms?.dingtalk?.cardTemplateId ?? "",
                 allowedUserIds: (file.platforms?.dingtalk?.allowedUserIds ?? []).join(", "),
             },
+            workbuddy: {
+                enabled: file.platforms?.workbuddy?.enabled ?? Boolean(file.platforms?.workbuddy?.accessToken && file.platforms?.workbuddy?.refreshToken && file.platforms?.workbuddy?.userId),
+                aiCommand: file.platforms?.workbuddy?.aiCommand ?? "",
+                accessToken: file.platforms?.workbuddy?.accessToken ?? "",
+                refreshToken: file.platforms?.workbuddy?.refreshToken ?? "",
+                userId: file.platforms?.workbuddy?.userId ?? "",
+                baseUrl: file.platforms?.workbuddy?.baseUrl ?? "",
+                allowedUserIds: (file.platforms?.workbuddy?.allowedUserIds ?? []).join(", "),
+            },
         },
         ai: {
             aiCommand: file.aiCommand ?? "claude",
@@ -276,6 +295,12 @@ function validatePayload(payload) {
         errors.push("DingTalk client ID is required.");
     if (payload.platforms.dingtalk.enabled && !clean(payload.platforms.dingtalk.clientSecret))
         errors.push("DingTalk client secret is required.");
+    if (payload.platforms.workbuddy.enabled && !clean(payload.platforms.workbuddy.accessToken))
+        errors.push("WorkBuddy access token is required.");
+    if (payload.platforms.workbuddy.enabled && !clean(payload.platforms.workbuddy.refreshToken))
+        errors.push("WorkBuddy refresh token is required.");
+    if (payload.platforms.workbuddy.enabled && !clean(payload.platforms.workbuddy.userId))
+        errors.push("WorkBuddy user ID is required.");
     if (!clean(payload.ai.claudeWorkDir))
         errors.push("Default work directory is required.");
     if (!Number.isFinite(payload.ai.claudeTimeoutMs) || payload.ai.claudeTimeoutMs <= 0)
@@ -330,6 +355,17 @@ function validateConfigForPlatform(platform, config) {
                 errors.push("DingTalk client secret is required and must be a non-empty string.");
             }
             break;
+        case "workbuddy":
+            if (!c.accessToken || typeof c.accessToken !== "string" || !clean(c.accessToken)) {
+                errors.push("WorkBuddy access token is required and must be a non-empty string.");
+            }
+            if (!c.refreshToken || typeof c.refreshToken !== "string" || !clean(c.refreshToken)) {
+                errors.push("WorkBuddy refresh token is required and must be a non-empty string.");
+            }
+            if (!c.userId || typeof c.userId !== "string" || !clean(c.userId)) {
+                errors.push("WorkBuddy user ID is required and must be a non-empty string.");
+            }
+            break;
         default:
             errors.push(`Unknown platform: ${platform}`);
     }
@@ -455,6 +491,34 @@ async function probeDingTalk(config) {
     }
     return "DingTalk credentials are valid.";
 }
+async function probeWorkBuddy(config) {
+    const accessToken = clean(String(config.accessToken ?? ""));
+    const refreshToken = clean(String(config.refreshToken ?? ""));
+    const userId = clean(String(config.userId ?? ""));
+    if (!accessToken || !refreshToken || !userId)
+        throw new Error("WorkBuddy access token, refresh token, and user ID are required.");
+    const baseUrl = clean(String(config.baseUrl ?? "")) || "https://copilot.tencent.com";
+    // Validate credentials by attempting to register workspace
+    const response = await fetch(`${baseUrl}/api/copilot/workspace/register`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            "authorization": `Bearer ${accessToken}`,
+        },
+        body: JSON.stringify({
+            userId,
+            hostId: "open-im-test",
+            workspaceId: "open-im-test-workspace",
+            workspaceName: "OpenIM Test Workspace",
+        }),
+        signal: AbortSignal.timeout(TEST_TIMEOUT_MS),
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`WorkBuddy authentication failed: ${body.slice(0, 200) || `HTTP ${response.status}`}`);
+    }
+    return "WorkBuddy credentials are valid.";
+}
 export async function testPlatformConfig(platform, config) {
     const errors = validateConfigForPlatform(platform, config);
     if (errors.length > 0) {
@@ -471,6 +535,8 @@ export async function testPlatformConfig(platform, config) {
             return probeWeWork(config);
         case "dingtalk":
             return probeDingTalk(config);
+        case "workbuddy":
+            return probeWorkBuddy(config);
         default:
             throw new Error(`Unknown platform: ${platform}`);
     }
@@ -557,6 +623,16 @@ function toFileConfig(payload, existing) {
                 cardTemplateId: clean(payload.platforms.dingtalk.cardTemplateId),
                 allowedUserIds: splitCsv(payload.platforms.dingtalk.allowedUserIds),
             },
+            workbuddy: {
+                ...existing.platforms?.workbuddy,
+                enabled: payload.platforms.workbuddy.enabled,
+                aiCommand: clean(payload.platforms.workbuddy.aiCommand),
+                accessToken: clean(payload.platforms.workbuddy.accessToken),
+                refreshToken: clean(payload.platforms.workbuddy.refreshToken),
+                userId: clean(payload.platforms.workbuddy.userId),
+                baseUrl: clean(payload.platforms.workbuddy.baseUrl),
+                allowedUserIds: splitCsv(payload.platforms.workbuddy.allowedUserIds),
+            },
         },
     };
 }
@@ -812,6 +888,7 @@ export async function startWebConfigServer(options) {
             const fileQQ = file.platforms?.qq;
             const fileWework = file.platforms?.wework;
             const fileDingtalk = file.platforms?.dingtalk;
+            const fileWorkbuddy = file.platforms?.workbuddy;
             const telegramBotToken = process.env.TELEGRAM_BOT_TOKEN ?? fileTelegram?.botToken ?? file.telegramBotToken;
             const feishuAppId = process.env.FEISHU_APP_ID ?? fileFeishu?.appId ?? file.feishuAppId;
             const feishuAppSecret = process.env.FEISHU_APP_SECRET ?? fileFeishu?.appSecret ?? file.feishuAppSecret;
@@ -821,6 +898,9 @@ export async function startWebConfigServer(options) {
             const weworkSecret = process.env.WEWORK_SECRET ?? fileWework?.secret;
             const dingtalkClientId = process.env.DINGTALK_CLIENT_ID ?? fileDingtalk?.clientId;
             const dingtalkClientSecret = process.env.DINGTALK_CLIENT_SECRET ?? fileDingtalk?.clientSecret;
+            const workbuddyAccessToken = fileWorkbuddy?.accessToken;
+            const workbuddyRefreshToken = fileWorkbuddy?.refreshToken;
+            const workbuddyUserId = fileWorkbuddy?.userId;
             const platforms = {};
             // 检查 Telegram
             platforms.telegram = {
@@ -857,6 +937,13 @@ export async function startWebConfigServer(options) {
                 healthy: !!(dingtalkClientId && dingtalkClientSecret),
                 message: (dingtalkClientId && dingtalkClientSecret) ? "Client ID and Secret configured" : "Missing credentials"
             };
+            // 检查 WorkBuddy
+            platforms.workbuddy = {
+                configured: !!(workbuddyAccessToken && workbuddyRefreshToken && workbuddyUserId),
+                enabled: !!(workbuddyAccessToken && workbuddyRefreshToken && workbuddyUserId) && fileWorkbuddy?.enabled !== false,
+                healthy: !!(workbuddyAccessToken && workbuddyRefreshToken && workbuddyUserId),
+                message: (workbuddyAccessToken && workbuddyRefreshToken && workbuddyUserId) ? "OAuth credentials configured" : "Missing credentials"
+            };
             json(response, 200, { platforms, serviceStatus: getServiceStatus() });
             return;
         }

package/dist/dingtalk/client.js

@@ -7,7 +7,9 @@ const TEXT_MSG_KEY = 'sampleText';
 const DINGTALK_STREAM_HOST = 'wss-open-connection.dingtalk.com';
 let client = null;
 let messageHandler = null;
+// sessionWebhook 有过期时间（约 2 小时），需要记录时间戳
 const sessionWebhookByChat = new Map();
+const WEBHOOK_TTL_MS = 90 * 60 * 1000; // 90 分钟后视为过期
 const unionIdByUserId = new Map();
 let dingtalkWarnFilterInstalled = false;
 export function shouldSuppressDingTalkSocketWarn(args) {
@@ -44,13 +46,19 @@ function getClient() {
 export function registerSessionWebhook(chatId, sessionWebhook) {
     if (!chatId || !sessionWebhook)
         return;
-    sessionWebhookByChat.set(chatId, sessionWebhook);
+    sessionWebhookByChat.set(chatId, { webhook: sessionWebhook, registeredAt: Date.now() });
 }
 async function sendByWebhook(chatId, body) {
-    const sessionWebhook = sessionWebhookByChat.get(chatId);
-    if (!sessionWebhook) {
+    const entry = sessionWebhookByChat.get(chatId);
+    if (!entry) {
         throw new Error(`DingTalk sessionWebhook unavailable for chat ${chatId}`);
     }
+    // 检查 webhook 是否过期
+    if (Date.now() - entry.registeredAt > WEBHOOK_TTL_MS) {
+        sessionWebhookByChat.delete(chatId);
+        throw new Error(`DingTalk sessionWebhook expired for chat ${chatId}`);
+    }
+    const sessionWebhook = entry.webhook;
     const accessToken = await getClient().getAccessToken();
     const res = await fetch(sessionWebhook, {
         method: 'POST',

package/dist/dingtalk/event-handler.js

@@ -185,7 +185,18 @@ export function setupDingTalkHandlers(config, sessionManager) {
             : undefined;
         log.info(`[AI_REQUEST] Running ${aiCommand} for user ${userId}, sessionId=${sessionId ?? 'new'}`);
         const toolId = aiCommand;
-        const msgId = await sendThinkingMessage(chatId, replyToMessageId, toolId, dingtalkTarget);
+        let msgId;
+        try {
+            msgId = await sendThinkingMessage(chatId, replyToMessageId, toolId, dingtalkTarget);
+        }
+        catch (err) {
+            log.error('Failed to send thinking message:', err);
+            try {
+                await sendTextReply(chatId, '启动 AI 处理失败，请重试。');
+            }
+            catch { /* ignore */ }
+            return;
+        }
         const stopTyping = startTypingLoop(chatId);
         const taskKey = `${userId}:${msgId}`;
         await runAITask({ config, sessionManager }, { userId, chatId, workDir, sessionId, convId, platform: 'dingtalk', taskKey }, prompt, toolAdapter, {

package/dist/feishu/event-handler.js

@@ -17,6 +17,95 @@ 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 { /* 卡片方式失败，降级 */ }
+    // 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 { /* 纯文本也失败 */ }
+    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({
@@ -62,14 +151,39 @@ export function setupFeishuHandlers(config, sessionManager) {
         }
         catch (err) {
             log.error('Failed to send thinking card:', err);
+            // 检测是否为飞书权限不足
+            if (isPermissionError(err)) {
+                const guide = buildPermissionGuideMessage(err);
+                await sendPermissionFallback(chatId, guide).catch(() => { });
+            }
+            else {
+                try {
+                    await sendTextReply(chatId, '启动 AI 处理失败，请重试。');
+                }
+                catch { /* ignore */ }
+            }
             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,

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;
@@ -147,99 +148,116 @@ function startHeartbeat(intervalMs) {
     }, 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

@@ -144,7 +144,18 @@ 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 { /* ignore */ }
+            return;
+        }
         const stopTyping = startTypingLoop();
         const taskKey = `${userId}:${msgId}`;
         await runAITask({ config, sessionManager }, { userId, chatId, workDir, sessionId, convId, platform: "qq", taskKey }, prompt, toolAdapter, {

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/telegram/client.js

@@ -39,8 +39,8 @@ export async function initTelegram(config, setupHandlers) {
                 await new Promise((r) => setTimeout(r, delayMs));
                 return launchWithRetry(attempt + 1);
             }
-            log.error("Telegram gave up reconnecting, exiting");
-            process.exit(1);
+            log.error("Telegram gave up reconnecting, skipping");
+            // 不再 exit(1)，让其他通道继续运行
         }
     };
     void launchWithRetry();

package/dist/telegram/event-handler.js

@@ -107,6 +107,10 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
         }
         catch (err) {
             log.error("Failed to send thinking message:", err);
+            try {
+                await sendTextReply(chatId, "启动 AI 处理失败，请重试。");
+            }
+            catch { /* ignore */ }
             return;
         }
         const stopTyping = startTypingLoop(chatId);

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,6 +97,7 @@ 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;
@@ -108,6 +114,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);
@@ -190,11 +197,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 +241,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 +316,7 @@ function saveToken() {
  * Stop WeChat client
  */
 export function stopWeChat() {
+    isStopping = true;
     stopHeartbeat();
     if (reconnectTimer) {
         clearTimeout(reconnectTimer);

package/dist/wechat/event-handler.js

@@ -130,6 +130,10 @@ export function setupWeChatHandlers(config, sessionManager) {
         }
         catch (err) {
             log.error('Failed to send thinking message:', err);
+            try {
+                await sendTextReply(chatId, '启动 AI 处理失败，请重试。');
+            }
+            catch { /* ignore */ }
             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

@@ -185,7 +185,18 @@ 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 { /* ignore */ }
+                return;
+            }
             const stopTyping = startTypingLoop(chatId);
             const taskKey = `${userId}:${msgId}`;
             await runAITask({ config, sessionManager }, { userId, chatId, workDir, sessionId, convId, platform: 'wework', taskKey }, prompt, toolAdapter, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.8.1-beta.8",
+  "version": "1.8.1",
   "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, CodeBuddy)",
   "type": "module",
   "main": "dist/index.js",
@@ -48,6 +48,7 @@
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.76",
     "@larksuiteoapi/node-sdk": "^1.59.0",
+    "@wu529778790/open-im": "^1.8.1-beta.8",
     "centrifuge": "^5.3.0",
     "dingtalk-stream": "^2.1.4",
     "prompts": "^2.4.2",