@wu529778790/open-im 1.10.2-beta.0 → 1.10.2-beta.2

package/dist/codebuddy/cli-runner.js

@@ -294,7 +294,7 @@ export function runCodeBuddy(cliPath, prompt, sessionId, workDir, callbacks, opt
                     handlePayload(JSON.parse(payload));
                 }
                 catch {
-                    // Ignore trailing partial payloads.
+                    log.debug(`Ignoring trailing partial CodeBuddy payload on close`);
                 }
             }
             if (completed)

package/dist/codex/cli-runner.js

@@ -117,7 +117,8 @@ function extractCodexJsFromCmdShim(cmdPath) {
         const relativeJsPath = match[1].replace(/\\/g, '/');
         return join(dirname(cmdPath), relativeJsPath);
     }
-    catch {
+    catch (err) {
+        log.debug(`Failed to extract Codex JS path from cmd shim ${cmdPath}:`, err);
         return null;
     }
 }
@@ -152,7 +153,8 @@ function resolveWindowsCodexLaunch(cliPath, args) {
         windowsCodexLaunchCache.set(cliPath, resolved);
         return { command: resolved.command, args: [...resolved.args, ...args] };
     }
-    catch {
+    catch (err) {
+        log.debug(`Failed to resolve Windows Codex launch for ${cliPath}:`, err);
         windowsCodexLaunchCache.set(cliPath, null);
         return null;
     }

package/dist/commands/handler.js

@@ -1,6 +1,8 @@
 import { resolvePlatformAiCommand } from '../config.js';
 import { escapePathForMarkdown } from '../shared/utils.js';
 import { TERMINAL_ONLY_COMMANDS } from '../constants.js';
+import { createLogger } from '../logger.js';
+const log = createLogger('Commands');
 import { execFile } from 'node:child_process';
 import { readdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
@@ -136,8 +138,8 @@ export function listDirectories(basePath) {
             .sort((a, b) => a.name.localeCompare(b.name)); // 按名称排序
         dirs.push(...subDirs);
     }
-    catch {
-        // 忽略错误
+    catch (err) {
+        log.debug('Failed to list subdirectories:', err);
     }
     return dirs;
 }

package/dist/config-web-page-script.js

@@ -108,8 +108,7 @@ export const PAGE_SCRIPT = String.raw `      const platformDefinitions = [
         [
           "headerValidateButton",
           "headerSaveButton",
-          "headerStartButton",
-          "headerStopButton",
+          "headerToggleServiceButton",
           "langButton",
         ].forEach((id) => {
           const node = el(id);
@@ -233,8 +232,7 @@ export const PAGE_SCRIPT = String.raw `      const platformDefinitions = [
         buttons: [
           { id: "headerValidateButton", key: "validate" },
           { id: "headerSaveButton", key: "save" },
-          { id: "headerStartButton", key: "start" },
-          { id: "headerStopButton", key: "stop" },
+          { id: "headerToggleServiceButton", key: "start" },
         ],
         testButtons: [
           { prefix: "test-", key: "test" },
@@ -623,6 +621,12 @@ export const PAGE_SCRIPT = String.raw `      const platformDefinitions = [
           serviceState.textContent = serviceStateText;
           serviceState.className = "badge " + (data.running ? "badge-success" : "badge-default");
         }
+        // Update toggle button text and style
+        const toggleBtn = el("headerToggleServiceButton");
+        if (toggleBtn) {
+          toggleBtn.textContent = data.running ? t("stop") : t("start");
+          toggleBtn.className = "btn btn-sm " + (data.running ? "btn-danger" : "btn-primary");
+        }
         return data;
       }
 
@@ -750,8 +754,14 @@ export const PAGE_SCRIPT = String.raw `      const platformDefinitions = [
         };
         el("headerValidateButton").onclick = validate;
         el("headerSaveButton").onclick = onSaveClick;
-        el("headerStartButton").onclick = onStartClick;
-        el("headerStopButton").onclick = stopService;
+        el("headerToggleServiceButton").onclick = async () => {
+          const status = await refreshStatus();
+          if (status.running) {
+            await stopService();
+          } else {
+            await onStartClick();
+          }
+        };
 
         // Platform test buttons
         platformKeys.forEach((platform) => {

package/dist/config-web-page-template.js

@@ -866,8 +866,7 @@ export const PAGE_HTML_PREFIX = String.raw `<!doctype html>
           <div class="main-header-toolbar" id="headerToolbar" role="toolbar" aria-label="Bridge controls">
             <button type="button" id="headerValidateButton" class="btn btn-warning btn-sm">Validate</button>
             <button type="button" id="headerSaveButton" class="btn btn-secondary btn-sm">Save config</button>
-            <button type="button" id="headerStartButton" class="btn btn-primary btn-sm">Start bridge</button>
-            <button type="button" id="headerStopButton" class="btn btn-danger btn-sm">Stop bridge</button>
+            <button type="button" id="headerToggleServiceButton" class="btn btn-primary btn-sm">Start bridge</button>
           </div>
         </header>
 

package/dist/config-web.js

@@ -894,67 +894,7 @@ export async function startWebConfigServer(options) {
         }
         if (request.method === "GET" && requestUrl.pathname === "/api/health") {
             const file = loadFileConfig();
-            const fileTelegram = file.platforms?.telegram;
-            const fileFeishu = file.platforms?.feishu;
-            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;
-            const qqAppId = process.env.QQ_BOT_APPID ?? process.env.QQ_APP_ID ?? fileQQ?.appId;
-            const qqSecret = process.env.QQ_BOT_SECRET ?? process.env.QQ_SECRET ?? fileQQ?.secret;
-            const weworkCorpId = process.env.WEWORK_CORP_ID ?? fileWework?.corpId;
-            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 = {
-                configured: !!telegramBotToken,
-                enabled: !!telegramBotToken && fileTelegram?.enabled !== false,
-                healthy: !!telegramBotToken,
-                message: telegramBotToken ? "Token configured" : "Token not configured"
-            };
-            // 检查 Feishu
-            platforms.feishu = {
-                configured: !!(feishuAppId && feishuAppSecret),
-                enabled: !!(feishuAppId && feishuAppSecret) && fileFeishu?.enabled !== false,
-                healthy: !!(feishuAppId && feishuAppSecret),
-                message: (feishuAppId && feishuAppSecret) ? "App ID and Secret configured" : "Missing credentials"
-            };
-            // 检查 QQ
-            platforms.qq = {
-                configured: !!(qqAppId && qqSecret),
-                enabled: !!(qqAppId && qqSecret) && fileQQ?.enabled !== false,
-                healthy: !!(qqAppId && qqSecret),
-                message: (qqAppId && qqSecret) ? "App ID and Secret configured" : "Missing credentials"
-            };
-            // 检查 WeWork
-            platforms.wework = {
-                configured: !!(weworkCorpId && weworkSecret),
-                enabled: !!(weworkCorpId && weworkSecret) && fileWework?.enabled !== false,
-                healthy: !!(weworkCorpId && weworkSecret),
-                message: (weworkCorpId && weworkSecret) ? "Corp ID and Secret configured" : "Missing credentials"
-            };
-            // 检查 DingTalk
-            platforms.dingtalk = {
-                configured: !!(dingtalkClientId && dingtalkClientSecret),
-                enabled: !!(dingtalkClientId && dingtalkClientSecret) && fileDingtalk?.enabled !== false,
-                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"
-            };
+            const platforms = getHealthPlatformSnapshot(file);
             json(response, 200, { platforms, serviceStatus: getServiceStatus() });
             return;
         }

package/dist/dingtalk/event-handler.js

@@ -2,6 +2,8 @@ import { configureDingTalkMessageSender, sendThinkingMessage, updateMessage, sen
 import { ackMessage, downloadRobotMessageFile, registerSessionWebhook } from './client.js';
 import { createPlatformEventContext } from '../platform/create-event-context.js';
 import { createPlatformAIRequestHandler } from '../platform/handle-ai-request.js';
+import { handleTextFlow } from '../platform/handle-text-flow.js';
+import { handleEnqueueResult } from '../shared/utils.js';
 import { setActiveChatId, setDingTalkActiveTarget } from '../shared/active-chats.js';
 import { setChatUser } from '../shared/chat-user-map.js';
 import { createLogger } from '../logger.js';
@@ -246,12 +248,7 @@ export function setupDingTalkHandlers(config, sessionManager) {
                 return;
             }
             const enqueueResult = await enqueuePrompt(userId, chatId, prompt, dingtalkTarget);
-            if (enqueueResult === 'rejected') {
-                await sendTextReply(chatId, '请求队列已满，请稍后再试。');
-            }
-            else if (enqueueResult === 'queued') {
-                await sendTextReply(chatId, '您的请求已排队等待。');
-            }
+            await handleEnqueueResult(enqueueResult, (text) => sendTextReply(chatId, text));
             ackMessage(callbackId, { queued: enqueueResult, kind });
             return;
         }
@@ -259,26 +256,29 @@ export function setupDingTalkHandlers(config, sessionManager) {
             ackMessage(callbackId, { ignored: 'empty text' });
             return;
         }
-        try {
-            const handled = await commandHandler.dispatch(text, chatId, userId, 'dingtalk', (userId, chatId, prompt, workDir, convId) => {
-                return handleAIRequest({ userId, chatId, prompt, workDir, convId });
-            });
-            if (handled) {
-                ackMessage(callbackId, { handled: true });
-                return;
-            }
-        }
-        catch (err) {
-            log.error('Error in commandHandler.dispatch:', err);
-        }
-        const enqueueResult = await enqueuePrompt(userId, chatId, text, dingtalkTarget);
-        if (enqueueResult === 'rejected') {
-            await sendTextReply(chatId, '请求队列已满，请稍后再试。');
-        }
-        else if (enqueueResult === 'queued') {
-            await sendTextReply(chatId, '您的请求已排队等待。');
+        // Use shared text flow with customEnqueue to carry dingtalkTarget
+        const processed = await handleTextFlow({
+            platform: 'dingtalk',
+            userId,
+            chatId,
+            text,
+            ctx,
+            handleAIRequest,
+            sendTextReply,
+            workDir: sessionManager.getWorkDir(userId),
+            convId: sessionManager.getConvId(userId),
+            queueFullMessage: '请求队列已满，请稍后再试。',
+            queuedMessage: '您的请求已排队等待。',
+            customEnqueue: (prompt) => {
+                return enqueuePrompt(userId, chatId, prompt, dingtalkTarget);
+            },
+        });
+        if (!processed) {
+            // Access denied
+            ackMessage(callbackId, { denied: true });
+            return;
         }
-        ackMessage(callbackId, { queued: enqueueResult });
+        ackMessage(callbackId, { handled: true });
     }
     return {
         stop: () => { },

package/dist/feishu/client.js

@@ -103,7 +103,7 @@ export async function initFeishu(config, eventHandler) {
                 app_secret: config.feishuAppSecret,
             },
         });
-        if (tokenResp.code !== 0 || !tokenResp.data) {
+        if (tokenResp.code !== 0) {
             throw new Error(`Feishu credentials invalid: ${tokenResp.msg} (code: ${tokenResp.code})`);
         }
         log.info('Feishu credentials validated successfully');

package/dist/feishu/event-handler.js

@@ -11,6 +11,7 @@ import { buildProgressNote } from '../shared/message-note.js';
 import { createPlatformEventContext } from '../platform/create-event-context.js';
 import { createPlatformAIRequestHandler } from '../platform/handle-ai-request.js';
 import { handleTextFlow } from '../platform/handle-text-flow.js';
+import { handleEnqueueResult } from '../shared/utils.js';
 import { isPermissionError, handlePermissionError } from './permission.js';
 const log = createLogger('FeishuHandler');
 async function downloadFeishuMessageResource(client, messageId, fileKey, type, options) {
@@ -188,13 +189,12 @@ export function setupFeishuHandlers(config, sessionManager) {
                 const messageId = message.message_id ?? '';
                 const msgType = message.message_type;
                 const contentStr = message.content ?? '{}';
-                log.info(`[handleEvent] Parsed: chatId=${chatId}, msgType=${msgType}`);
                 log.info(`Message: chatId=${chatId}, messageId=${messageId}, msgType=${msgType}`);
                 // Parse message content
                 let content;
                 try {
                     content = JSON.parse(contentStr);
-                    log.info(`Parsed content:`, JSON.stringify(content).slice(0, 200));
+                    log.debug(`Parsed content:`, JSON.stringify(content).slice(0, 200));
                 }
                 catch (err) {
                     log.error('Failed to parse message content:', err);
@@ -223,7 +223,7 @@ export function setupFeishuHandlers(config, sessionManager) {
                         text = text.replace(/ /gi, ' ');
                         // 最后做一次首尾 trim，但不动中间的空格
                         text = text.trim();
-                        log.info(`[MSG] Type=text, User=${senderId}, Length=${text.length}, Content="${text}"`);
+                        log.debug(`[MSG] Type=text, User=${senderId}, Length=${text.length}, Content="${text}"`);
                     }
                     else if (msgType === 'post') {
                         // Feishu rich text/post messages - extract text content
@@ -252,7 +252,7 @@ export function setupFeishuHandlers(config, sessionManager) {
                             return '';
                         }
                         if (rawContent && Array.isArray(rawContent)) {
-                            log.info(`[MSG] Post content structure:`, JSON.stringify(rawContent).slice(0, 500));
+                            log.debug(`[MSG] Post content structure:`, JSON.stringify(rawContent).slice(0, 500));
                             for (const section of rawContent) {
                                 if (Array.isArray(section)) {
                                     // 二维数组：段落内多个元素
@@ -266,7 +266,7 @@ export function setupFeishuHandlers(config, sessionManager) {
                             }
                         }
                         text = text.trim();
-                        log.info(`[MSG] Type=post, User=${senderId}, Length=${text.length}, Content="${text}"`);
+                        log.debug(`[MSG] Type=post, User=${senderId}, Length=${text.length}, Content="${text}"`);
                     }
                     if (!text) {
                         log.warn(`[MSG] ${msgType} message has no extractable text content`);
@@ -321,15 +321,11 @@ export function setupFeishuHandlers(config, sessionManager) {
                         const enqueueResult = ctx.requestQueue.enqueue(senderId, convId, prompt, async (p, signal) => {
                             await handleAIRequest({ userId: senderId, chatId, prompt: p, workDir: work, convId, replyToMessageId: messageId, signal });
                         });
-                        if (enqueueResult === 'rejected') {
-                            sendTextReply(chatId, '请求队列已满，请稍后再试。').catch((sendErr) => {
-                                log.warn('[feishu] Failed to send queue full message for image:', sendErr);
-                            });
+                        try {
+                            await handleEnqueueResult(enqueueResult, (text) => sendTextReply(chatId, text));
                         }
-                        else if (enqueueResult === 'queued') {
-                            sendTextReply(chatId, '您的请求已排队等待。').catch((sendErr) => {
-                                log.warn('[feishu] Failed to send queued message for image:', sendErr);
-                            });
+                        catch (sendErr) {
+                            log.warn('[feishu] Failed to send enqueue result message for image:', sendErr);
                         }
                     }
                     catch (err) {
@@ -369,15 +365,11 @@ export function setupFeishuHandlers(config, sessionManager) {
                         const enqueueResult = ctx.requestQueue.enqueue(senderId, convId, prompt, async (p, signal) => {
                             await handleAIRequest({ userId: senderId, chatId, prompt: p, workDir, convId, replyToMessageId: messageId, signal });
                         });
-                        if (enqueueResult === 'rejected') {
-                            sendTextReply(chatId, '请求队列已满，请稍后再试。').catch((sendErr) => {
-                                log.warn(`[feishu] Failed to send queue full message for ${msgType}:`, sendErr);
-                            });
+                        try {
+                            await handleEnqueueResult(enqueueResult, (text) => sendTextReply(chatId, text));
                         }
-                        else if (enqueueResult === 'queued') {
-                            sendTextReply(chatId, '您的请求已排队等待。').catch((sendErr) => {
-                                log.warn(`[feishu] Failed to send queued message for ${msgType}:`, sendErr);
-                            });
+                        catch (sendErr) {
+                            log.warn(`[feishu] Failed to send enqueue result message for ${msgType}:`, sendErr);
                         }
                     }
                     catch (err) {
@@ -389,7 +381,7 @@ export function setupFeishuHandlers(config, sessionManager) {
                 }
                 else {
                     log.warn(`[MSG] Unsupported message type: ${msgType}, senderId=${senderId}`);
-                    log.info(`[MSG] Content structure:`, JSON.stringify(content).slice(0, 500));
+                    log.debug(`[MSG] Content structure:`, JSON.stringify(content).slice(0, 500));
                 }
             }
         }

package/dist/feishu/message-sender.js

@@ -76,7 +76,7 @@ async function getTenantAccessToken() {
             app_secret: client.appSecret,
         },
     });
-    if (resp.code !== 0 || !resp.data) {
+    if (resp.code !== 0) {
         throw new Error(`Failed to get tenant access token: ${resp.msg}`);
     }
     return resp.data.tenant_access_token;

package/dist/index.js

@@ -296,7 +296,7 @@ export async function main() {
         // WebSocket "not open" errors are transient — the connection will auto-reconnect.
         // Exiting would take down all platforms, so just log and continue.
         if (msg.includes("WebSocket is not open") || msg.includes("readyState")) {
-            log.warn("Transient WebSocket error (ignored, will reconnect):", err);
+            log.debug("Transient WebSocket error (ignored, will reconnect):", err);
             return;
         }
         log.error("Uncaught exception (process will exit):", err);

package/dist/platform/handle-ai-request.js

@@ -97,42 +97,26 @@ export function createPlatformAIRequestHandler(deps) {
         const mergedCallbacks = { ...defaultCallbacks };
         // Use taskCallbacksFactory if provided (has full context access)
         let factoryCallbacks;
-        if (taskCallbacksFactory) {
-            factoryCallbacks = taskCallbacksFactory({
+        const platformOverrides = taskCallbacksFactory
+            ? (factoryCallbacks = taskCallbacksFactory({
                 chatId,
                 msgId,
                 taskKey,
                 userId,
                 toolId,
                 replyToMessageId,
-            });
-            if (factoryCallbacks.streamUpdate) {
-                mergedCallbacks.streamUpdate = factoryCallbacks.streamUpdate;
-            }
-            if (factoryCallbacks.sendComplete) {
-                mergedCallbacks.sendComplete = factoryCallbacks.sendComplete;
-            }
-            if (factoryCallbacks.sendError) {
-                mergedCallbacks.sendError = factoryCallbacks.sendError;
-            }
-            if (factoryCallbacks.onFirstContent) {
-                mergedCallbacks.onFirstContent = factoryCallbacks.onFirstContent;
-            }
-        }
-        else if (taskCallbacks) {
-            // Fall back to static taskCallbacks
-            if (taskCallbacks.streamUpdate) {
-                mergedCallbacks.streamUpdate = taskCallbacks.streamUpdate;
-            }
-            if (taskCallbacks.sendComplete) {
-                mergedCallbacks.sendComplete = taskCallbacks.sendComplete;
-            }
-            if (taskCallbacks.sendError) {
-                mergedCallbacks.sendError = taskCallbacks.sendError;
-            }
-            if (taskCallbacks.onFirstContent) {
-                mergedCallbacks.onFirstContent = taskCallbacks.onFirstContent;
-            }
+            }))
+            : taskCallbacks;
+        if (platformOverrides) {
+            const { streamUpdate, sendComplete, sendError, onFirstContent } = platformOverrides;
+            if (streamUpdate)
+                mergedCallbacks.streamUpdate = streamUpdate;
+            if (sendComplete)
+                mergedCallbacks.sendComplete = sendComplete;
+            if (sendError)
+                mergedCallbacks.sendError = sendError;
+            if (onFirstContent)
+                mergedCallbacks.onFirstContent = onFirstContent;
         }
         if (onThinkingToText) {
             mergedCallbacks.onThinkingToText = onThinkingToText;

package/dist/platform/handle-text-flow.js

@@ -17,15 +17,12 @@
 import { setActiveChatId } from '../shared/active-chats.js';
 import { setChatUser } from '../shared/chat-user-map.js';
 import { createLogger } from '../logger.js';
+import { handleEnqueueResult, DEFAULT_QUEUE_FULL_MESSAGE, DEFAULT_QUEUED_MESSAGE } from '../shared/utils.js';
 const log = createLogger('TextFlow');
 /** Default access-denied message. */
 function defaultAccessDeniedMessage(userId) {
     return `抱歉，您没有访问权限。\n您的 ID: ${userId}`;
 }
-/** Default queue-full message. */
-const DEFAULT_QUEUE_FULL_MESSAGE = '请求队列已满，请稍后再试。';
-/** Default queued message. */
-const DEFAULT_QUEUED_MESSAGE = '您的请求已排队等待。';
 /**
  * Handles the full text message flow shared across all platforms.
  *
@@ -80,12 +77,7 @@ export async function handleTextFlow(params) {
     if (customEnqueue) {
         // Platform-specific enqueue (e.g., WorkBuddy with extra context)
         const enqueueResult = await customEnqueue(text);
-        if (enqueueResult === 'rejected') {
-            await sendTextReply(chatId, queueFullMessage);
-        }
-        else if (enqueueResult === 'queued') {
-            await sendTextReply(chatId, queuedMessage);
-        }
+        await handleEnqueueResult(enqueueResult, (text) => sendTextReply(chatId, text), { queueFull: queueFullMessage, queued: queuedMessage });
     }
     else {
         // Standard enqueue flow
@@ -103,12 +95,7 @@ export async function handleTextFlow(params) {
                 signal,
             });
         });
-        if (enqueueResult === 'rejected') {
-            await sendTextReply(chatId, queueFullMessage);
-        }
-        else if (enqueueResult === 'queued') {
-            await sendTextReply(chatId, queuedMessage);
-        }
+        await handleEnqueueResult(enqueueResult, (text) => sendTextReply(chatId, text), { queueFull: queueFullMessage, queued: queuedMessage });
     }
     return true;
 }

package/dist/qq/event-handler.js

@@ -9,6 +9,7 @@ import { setChatUser } from "../shared/chat-user-map.js";
 import { createPlatformEventContext } from "../platform/create-event-context.js";
 import { createPlatformAIRequestHandler } from "../platform/handle-ai-request.js";
 import { handleTextFlow } from "../platform/handle-text-flow.js";
+import { handleEnqueueResult } from "../shared/utils.js";
 const log = createLogger("QQHandler");
 const QQ_THROTTLE_MS = 1200;
 const QQ_MIN_STREAM_DELTA_CHARS = 80;
@@ -266,12 +267,7 @@ export function setupQQHandlers(config, sessionManager) {
                         signal,
                     });
                 });
-                if (enqueueResult === "rejected") {
-                    await sendTextReply(chatId, "请求队列已满，请稍后再试。");
-                }
-                else if (enqueueResult === "queued") {
-                    await sendTextReply(chatId, "您的请求已排队等待。");
-                }
+                await handleEnqueueResult(enqueueResult, (text) => sendTextReply(chatId, text));
                 log.info(`QQ message handled: user=${userId}, chat=${chatId}, attachments=${event.attachments?.length ?? 0}`);
             }
         }

package/dist/queue/request-queue.d.ts

@@ -1,6 +1,3 @@
-export declare class QueueTimeoutError extends Error {
-    constructor(timeoutMs: number);
-}
 export type EnqueueResult = 'running' | 'queued' | 'rejected';
 export declare class RequestQueue {
     private queues;

package/dist/queue/request-queue.js

@@ -1,13 +1,6 @@
 import { createLogger } from '../logger.js';
 const log = createLogger('Queue');
-export class QueueTimeoutError extends Error {
-    constructor(timeoutMs) {
-        super(`Task timed out after ${timeoutMs / 1000}s`);
-        this.name = 'QueueTimeoutError';
-    }
-}
 const MAX_QUEUE_SIZE = 3;
-const TASK_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
 export class RequestQueue {
     queues = new Map();
     enqueue(userId, convId, prompt, execute) {
@@ -25,7 +18,9 @@ export class RequestQueue {
             return 'queued';
         }
         q.running = true;
-        this.run(key, prompt, execute).catch(() => { });
+        this.run(key, prompt, execute).catch((err) => {
+            log.error(`Unhandled error in task execution for ${key}:`, err);
+        });
         return 'running';
     }
     /** 清除指定用户会话的所有排队任务（不中止正在运行的任务） */
@@ -42,34 +37,22 @@ export class RequestQueue {
     }
     async run(key, prompt, execute) {
         const controller = new AbortController();
-        let timer;
         try {
-            const timeoutPromise = new Promise((_, reject) => {
-                timer = setTimeout(() => {
-                    controller.abort();
-                    reject(new QueueTimeoutError(TASK_TIMEOUT_MS));
-                }, TASK_TIMEOUT_MS);
-            });
-            await Promise.race([execute(prompt, controller.signal), timeoutPromise]);
+            await execute(prompt, controller.signal);
         }
         catch (err) {
-            if (err instanceof QueueTimeoutError) {
-                log.error(`Timeout executing task for ${key}: ${err.message}`);
-            }
-            else {
-                log.error(`Error executing task for ${key}:`, err);
-            }
+            log.error(`Error executing task for ${key}:`, err);
             throw err;
         }
         finally {
-            if (timer)
-                clearTimeout(timer);
             const q = this.queues.get(key);
             if (!q)
                 return;
             const next = q.tasks.shift();
             if (next) {
-                setImmediate(() => this.run(key, next.prompt, next.execute).catch(() => { }));
+                setImmediate(() => this.run(key, next.prompt, next.execute).catch((err) => {
+                    log.error(`Unhandled error in next task execution for ${key}:`, err);
+                }));
             }
             else {
                 q.running = false;

package/dist/queue/request-queue.test.js

@@ -67,20 +67,6 @@ describe('RequestQueue', () => {
         const queue = new RequestQueue();
         expect(queue.clear('nobody', 'noconv')).toBe(0);
     });
-    it('times out long-running tasks after 10 minutes', async () => {
-        vi.useFakeTimers();
-        const queue = new RequestQueue();
-        const execute = vi.fn().mockReturnValue(new Promise(() => { })); // never resolves
-        queue.enqueue('user1', 'conv1', 'hello', execute);
-        expect(execute).toHaveBeenCalledTimes(1);
-        // Advance past 10-minute timeout
-        vi.advanceTimersByTime(10 * 60 * 1000 + 1);
-        // Let microtasks settle
-        await vi.advanceTimersByTimeAsync(100);
-        // The timed-out task should be done, queue should be cleared
-        expect(execute).toHaveBeenCalledTimes(1);
-        vi.useRealTimers();
-    });
     it('handles task execution error gracefully and processes next', async () => {
         const queue = new RequestQueue();
         const execute = vi.fn()
@@ -93,22 +79,4 @@ describe('RequestQueue', () => {
         expect(execute).toHaveBeenCalledWith('first', expect.any(AbortSignal));
         expect(execute).toHaveBeenCalledWith('second', expect.any(AbortSignal));
     });
-    it('aborts the AbortSignal on timeout', async () => {
-        vi.useFakeTimers();
-        const queue = new RequestQueue();
-        let receivedSignal;
-        const execute = vi.fn().mockImplementation(async (_prompt, signal) => {
-            receivedSignal = signal;
-            // Never resolve — simulates a stuck task
-            await new Promise(() => { });
-        });
-        queue.enqueue('user1', 'conv1', 'hello', execute);
-        await vi.advanceTimersByTimeAsync(10);
-        expect(receivedSignal?.aborted).toBe(false);
-        // Advance past timeout
-        vi.advanceTimersByTime(10 * 60 * 1000 + 1);
-        await vi.advanceTimersByTimeAsync(100);
-        expect(receivedSignal?.aborted).toBe(true);
-        vi.useRealTimers();
-    });
 });

package/dist/shared/active-chats.js

@@ -2,6 +2,8 @@ import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { writeFile, mkdir } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
 import { APP_HOME } from '../constants.js';
+import { createLogger } from '../logger.js';
+const log = createLogger('ActiveChats');
 const ACTIVE_CHATS_FILE = join(APP_HOME, 'data', 'active-chats.json');
 let data = {};
 let saveTimer = null;
@@ -25,8 +27,8 @@ function scheduleSave() {
             await mkdir(dirname(ACTIVE_CHATS_FILE), { recursive: true });
             await writeFile(ACTIVE_CHATS_FILE, JSON.stringify(data, null, 2), 'utf-8');
         }
-        catch {
-            /* ignore */
+        catch (err) {
+            log.warn('Failed to save active chats:', err);
         }
     }, 500);
 }
@@ -39,7 +41,8 @@ export function loadActiveChats() {
             }
         }
     }
-    catch {
+    catch (err) {
+        log.warn('Failed to load active chats, starting with empty state:', err);
         data = {};
     }
 }
@@ -84,7 +87,7 @@ export function flushActiveChats() {
             mkdirSync(dir, { recursive: true });
         writeFileSync(ACTIVE_CHATS_FILE, JSON.stringify(data, null, 2), 'utf-8');
     }
-    catch {
-        /* ignore */
+    catch (err) {
+        log.warn('Failed to flush active chats:', err);
     }
 }

package/dist/shared/ai-task.js

@@ -198,16 +198,18 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
                     }
                     settled = true;
                     log.error(`Task error for user ${ctx.userId}: ${error}`);
-                    if (aiCommand !== 'claude' && !isUsageLimitError(error)) {
+                    if (isUsageLimitError(error)) {
+                        // Usage limit errors: keep session for all tools (user can retry later)
+                        log.warn(`Keeping ${aiCommand} session for user ${ctx.userId} after usage limit error`);
+                    }
+                    else if (aiCommand !== 'claude') {
+                        // Non-CLI errors for codex/codebuddy: reset session to avoid stale state
                         if (ctx.convId)
                             sessionManager.clearSessionForConv(ctx.userId, ctx.convId, aiCommand);
                         else
                             sessionManager.clearActiveToolSession(ctx.userId, aiCommand);
                         log.warn(`Session reset for user ${ctx.userId} due to ${aiCommand} task error`);
                     }
-                    else if (aiCommand === 'codex' && isUsageLimitError(error)) {
-                        log.warn(`Keeping codex session for user ${ctx.userId} after usage limit error`);
-                    }
                     const friendlyError = hadSessionInvalid
                         ? '当前 Claude 会话已失效，已自动执行 /new 重置会话，请重新发送刚才的问题。'
                         : error;

package/dist/shared/utils.d.ts

@@ -1,5 +1,18 @@
+import type { EnqueueResult } from '../queue/request-queue.js';
 /** 消息头部品牌后缀，用于飞书等平台展示 */
 export declare const OPEN_IM_BRAND_SUFFIX = " \u00B7 \u901A\u8FC7 open-im \u63A7\u5236";
+/** Default queue-full message. */
+export declare const DEFAULT_QUEUE_FULL_MESSAGE = "\u8BF7\u6C42\u961F\u5217\u5DF2\u6EE1\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002";
+/** Default queued message. */
+export declare const DEFAULT_QUEUED_MESSAGE = "\u60A8\u7684\u8BF7\u6C42\u5DF2\u6392\u961F\u7B49\u5F85\u3002";
+/**
+ * Handle enqueue result by sending the appropriate notification message.
+ * Centralizes the repeated rejected/queued notification pattern across all platforms.
+ */
+export declare function handleEnqueueResult(enqueueResult: EnqueueResult, sendTextReply: (text: string) => Promise<void>, messages?: {
+    queueFull?: string;
+    queued?: string;
+}): Promise<void>;
 /** 转义路径供 Markdown 显示，防止 xxx.yyy.com 被解析为链接 */
 export declare function escapePathForMarkdown(path: string): string;
 /** AI 工具显示名称映射（aiCommand -> 用户友好名称） */

package/dist/shared/utils.js

@@ -1,5 +1,21 @@
 /** 消息头部品牌后缀，用于飞书等平台展示 */
 export const OPEN_IM_BRAND_SUFFIX = ' · 通过 open-im 控制';
+/** Default queue-full message. */
+export const DEFAULT_QUEUE_FULL_MESSAGE = '请求队列已满，请稍后再试。';
+/** Default queued message. */
+export const DEFAULT_QUEUED_MESSAGE = '您的请求已排队等待。';
+/**
+ * Handle enqueue result by sending the appropriate notification message.
+ * Centralizes the repeated rejected/queued notification pattern across all platforms.
+ */
+export async function handleEnqueueResult(enqueueResult, sendTextReply, messages) {
+    if (enqueueResult === 'rejected') {
+        await sendTextReply(messages?.queueFull ?? DEFAULT_QUEUE_FULL_MESSAGE);
+    }
+    else if (enqueueResult === 'queued') {
+        await sendTextReply(messages?.queued ?? DEFAULT_QUEUED_MESSAGE);
+    }
+}
 /** 转义路径供 Markdown 显示，防止 xxx.yyy.com 被解析为链接 */
 export function escapePathForMarkdown(path) {
     return `\`${path.replace(/`/g, '\\`')}\``;

package/dist/telegram/event-handler.js

@@ -9,6 +9,7 @@ import { buildErrorNote, buildProgressNote } from "../shared/message-note.js";
 import { createPlatformEventContext } from "../platform/create-event-context.js";
 import { createPlatformAIRequestHandler } from "../platform/handle-ai-request.js";
 import { handleTextFlow } from "../platform/handle-text-flow.js";
+import { handleEnqueueResult } from "../shared/utils.js";
 import { setActiveChatId } from "../shared/active-chats.js";
 import { setChatUser } from "../shared/chat-user-map.js";
 const log = createLogger("TgHandler");
@@ -245,6 +246,35 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
         runningTasks,
         taskCallbacksFactory: telegramTaskCallbacksFactory,
     });
+    /**
+     * Shared preamble for all media handlers: access check + chat registration.
+     * Returns null (with early return) if user is not allowed.
+     */
+    function registerMediaChat(tgCtx) {
+        const chatId = String(tgCtx.chat.id);
+        const userId = String(tgCtx.from?.id ?? "");
+        if (!accessControl.isAllowed(userId))
+            return null;
+        setActiveChatId("telegram", chatId);
+        setChatUser(chatId, userId, "telegram");
+        return { chatId, userId };
+    }
+    /**
+     * Generic handler for file-type media (document, audio, voice, video).
+     * Downloads the file, builds a prompt with media context, and enqueues.
+     */
+    async function handleFileMedia(ids, downloadFn, kind, metadata, caption, errorMsg) {
+        try {
+            const contextText = buildMediaContext(metadata, caption ? `Caption: ${caption}` : undefined);
+            const path = await downloadFn();
+            const enqueueResult = await enqueueSavedMedia(ids.userId, ids.chatId, kind, path, contextText);
+            await handleEnqueueResult(enqueueResult, (text) => sendTextReply(ids.chatId, text));
+        }
+        catch (err) {
+            log.error(`Failed to download ${kind}:`, err);
+            await sendTextReply(ids.chatId, errorMsg);
+        }
+    }
     async function enqueueSavedMedia(userId, chatId, kind, localPath, text) {
         const prompt = buildSavedMediaPrompt({
             source: "Telegram",
@@ -309,13 +339,10 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
         }
     });
     bot.on(message("photo"), async (ctx) => {
-        const chatId = String(ctx.chat.id);
-        const userId = String(ctx.from.id);
-        const caption = ctx.message.caption?.trim() || "";
-        if (!accessControl.isAllowed(userId))
+        const ids = registerMediaChat(ctx);
+        if (!ids)
             return;
-        setActiveChatId("telegram", chatId);
-        setChatUser(chatId, userId, "telegram");
+        const caption = ctx.message.caption?.trim() || "";
         const photos = ctx.message.photo;
         const largest = photos[photos.length - 1];
         const contextText = buildMediaContext({
@@ -328,134 +355,42 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
         }
         catch (err) {
             log.error("Failed to download photo:", err);
-            await sendTextReply(chatId, "图片下载失败。");
+            await sendTextReply(ids.chatId, "图片下载失败。");
             return;
         }
-        const enqueueResult = await enqueueSavedMedia(userId, chatId, "image", imagePath, contextText);
-        if (enqueueResult === "rejected") {
-            await sendTextReply(chatId, "请求队列已满，请稍后再试。");
-        }
-        else if (enqueueResult === "queued") {
-            await sendTextReply(chatId, "您的请求已排队等待。");
-        }
+        const enqueueResult = await enqueueSavedMedia(ids.userId, ids.chatId, "image", imagePath, contextText);
+        await handleEnqueueResult(enqueueResult, (text) => sendTextReply(ids.chatId, text));
     });
     bot.on(message("document"), async (ctx) => {
-        const chatId = String(ctx.chat.id);
-        const userId = String(ctx.from.id);
-        const caption = ctx.message.caption?.trim() || "";
-        if (!accessControl.isAllowed(userId))
+        const ids = registerMediaChat(ctx);
+        if (!ids)
             return;
-        setActiveChatId("telegram", chatId);
-        setChatUser(chatId, userId, "telegram");
-        try {
-            const document = ctx.message.document;
-            const contextText = buildMediaContext({
-                Filename: document.file_name,
-                MimeType: document.mime_type,
-                Size: document.file_size,
-            }, caption ? `Caption: ${caption}` : undefined);
-            const path = await downloadTelegramFile(bot, document.file_id, document.file_name ?? document.file_id, "bin");
-            const enqueueResult = await enqueueSavedMedia(userId, chatId, "document", path, contextText);
-            if (enqueueResult === "rejected") {
-                await sendTextReply(chatId, "请求队列已满，请稍后再试。");
-            }
-            else if (enqueueResult === "queued") {
-                await sendTextReply(chatId, "您的请求已排队等待。");
-            }
-        }
-        catch (err) {
-            log.error("Failed to download document:", err);
-            await sendTextReply(chatId, "文档下载失败。");
-        }
+        const caption = ctx.message.caption?.trim() || "";
+        const document = ctx.message.document;
+        await handleFileMedia(ids, () => downloadTelegramFile(bot, document.file_id, document.file_name ?? document.file_id, "bin"), "document", { Filename: document.file_name, MimeType: document.mime_type, Size: document.file_size }, caption || undefined, "文档下载失败。");
     });
     bot.on(message("audio"), async (ctx) => {
-        const chatId = String(ctx.chat.id);
-        const userId = String(ctx.from.id);
-        const caption = ctx.message.caption?.trim() || "";
-        if (!accessControl.isAllowed(userId))
+        const ids = registerMediaChat(ctx);
+        if (!ids)
             return;
-        setActiveChatId("telegram", chatId);
-        setChatUser(chatId, userId, "telegram");
-        try {
-            const audio = ctx.message.audio;
-            const contextText = buildMediaContext({
-                Filename: audio.file_name,
-                Title: audio.title,
-                Performer: audio.performer,
-                DurationSeconds: audio.duration,
-                MimeType: audio.mime_type,
-            }, caption ? `Caption: ${caption}` : undefined);
-            const path = await downloadTelegramFile(bot, audio.file_id, audio.file_name ?? audio.file_id, "mp3");
-            const enqueueResult = await enqueueSavedMedia(userId, chatId, "audio", path, contextText);
-            if (enqueueResult === "rejected") {
-                await sendTextReply(chatId, "请求队列已满，请稍后再试。");
-            }
-            else if (enqueueResult === "queued") {
-                await sendTextReply(chatId, "您的请求已排队等待。");
-            }
-        }
-        catch (err) {
-            log.error("Failed to download audio:", err);
-            await sendTextReply(chatId, "音频下载失败。");
-        }
+        const caption = ctx.message.caption?.trim() || "";
+        const audio = ctx.message.audio;
+        await handleFileMedia(ids, () => downloadTelegramFile(bot, audio.file_id, audio.file_name ?? audio.file_id, "mp3"), "audio", { Filename: audio.file_name, Title: audio.title, Performer: audio.performer, DurationSeconds: audio.duration, MimeType: audio.mime_type }, caption || undefined, "音频下载失败。");
     });
     bot.on(message("voice"), async (ctx) => {
-        const chatId = String(ctx.chat.id);
-        const userId = String(ctx.from.id);
-        if (!accessControl.isAllowed(userId))
+        const ids = registerMediaChat(ctx);
+        if (!ids)
             return;
-        setActiveChatId("telegram", chatId);
-        setChatUser(chatId, userId, "telegram");
-        try {
-            const voice = ctx.message.voice;
-            const contextText = buildMediaContext({
-                DurationSeconds: voice.duration,
-                MimeType: voice.mime_type,
-            });
-            const path = await downloadTelegramFile(bot, voice.file_id, voice.file_unique_id ?? voice.file_id, "ogg");
-            const enqueueResult = await enqueueSavedMedia(userId, chatId, "voice", path, contextText);
-            if (enqueueResult === "rejected") {
-                await sendTextReply(chatId, "请求队列已满，请稍后再试。");
-            }
-            else if (enqueueResult === "queued") {
-                await sendTextReply(chatId, "您的请求已排队等待。");
-            }
-        }
-        catch (err) {
-            log.error("Failed to download voice message:", err);
-            await sendTextReply(chatId, "语音下载失败。");
-        }
+        const voice = ctx.message.voice;
+        await handleFileMedia(ids, () => downloadTelegramFile(bot, voice.file_id, voice.file_unique_id ?? voice.file_id, "ogg"), "voice", { DurationSeconds: voice.duration, MimeType: voice.mime_type }, undefined, "语音下载失败。");
     });
     bot.on(message("video"), async (ctx) => {
-        const chatId = String(ctx.chat.id);
-        const userId = String(ctx.from.id);
-        const caption = ctx.message.caption?.trim() || "";
-        if (!accessControl.isAllowed(userId))
+        const ids = registerMediaChat(ctx);
+        if (!ids)
             return;
-        setActiveChatId("telegram", chatId);
-        setChatUser(chatId, userId, "telegram");
-        try {
-            const video = ctx.message.video;
-            const contextText = buildMediaContext({
-                Filename: video.file_name,
-                DurationSeconds: video.duration,
-                Width: video.width,
-                Height: video.height,
-                MimeType: video.mime_type,
-            }, caption ? `Caption: ${caption}` : undefined);
-            const path = await downloadTelegramFile(bot, video.file_id, video.file_name ?? video.file_unique_id ?? video.file_id, "mp4");
-            const enqueueResult = await enqueueSavedMedia(userId, chatId, "video", path, contextText);
-            if (enqueueResult === "rejected") {
-                await sendTextReply(chatId, "请求队列已满，请稍后再试。");
-            }
-            else if (enqueueResult === "queued") {
-                await sendTextReply(chatId, "您的请求已排队等待。");
-            }
-        }
-        catch (err) {
-            log.error("Failed to download video:", err);
-            await sendTextReply(chatId, "视频下载失败。");
-        }
+        const caption = ctx.message.caption?.trim() || "";
+        const video = ctx.message.video;
+        await handleFileMedia(ids, () => downloadTelegramFile(bot, video.file_id, video.file_name ?? video.file_unique_id ?? video.file_id, "mp4"), "video", { Filename: video.file_name, DurationSeconds: video.duration, Width: video.width, Height: video.height, MimeType: video.mime_type }, caption || undefined, "视频下载失败。");
     });
     return {
         stop: () => { },

package/dist/wework/event-handler.js

@@ -14,6 +14,7 @@ import { buildErrorNote, buildProgressNote } from '../shared/message-note.js';
 import { createPlatformEventContext } from '../platform/create-event-context.js';
 import { createPlatformAIRequestHandler } from '../platform/handle-ai-request.js';
 import { handleTextFlow } from '../platform/handle-text-flow.js';
+import { handleEnqueueResult } from '../shared/utils.js';
 import { decryptAes256CbcMedia, downloadMediaFromUrl, inferExtensionFromBuffer, inferExtensionFromContentType, saveBase64Media, saveBufferMedia, } from '../shared/media-storage.js';
 const log = createLogger('WeWorkHandler');
 const WEWORK_MEDIA_TIMEOUT_MS = 60_000;
@@ -243,12 +244,7 @@ export function setupWeWorkHandlers(config, sessionManager) {
         const enqueueResult = ctx.requestQueue.enqueue(userId, convId, prompt, async (nextPrompt, signal) => {
             await handleAIRequest({ userId, chatId, prompt: nextPrompt, workDir, convId, replyToMessageId: undefined, signal });
         });
-        if (enqueueResult === 'rejected') {
-            await sendTextReply(chatId, '请求队列已满，请稍后再试。', reqId);
-        }
-        else if (enqueueResult === 'queued') {
-            await sendTextReply(chatId, '您的请求已排队等待。', reqId);
-        }
+        await handleEnqueueResult(enqueueResult, (text) => sendTextReply(chatId, text, reqId));
     }
     async function handleEvent(data) {
         log.debug('[handleEvent] Called with data:', JSON.stringify(data).slice(0, 800));

package/dist/workbuddy/client.js

@@ -195,7 +195,14 @@ async function connect() {
             scheduleReconnect();
         },
         onError: (error) => {
-            log.error(`WorkBuddy Centrifuge error: ${error instanceof Error ? error.message : JSON.stringify(error)}`);
+            const msg = error instanceof Error ? error.message : JSON.stringify(error);
+            // "transport closed" is a transient WebSocket disconnect, not a real error
+            if (msg.includes('transport closed')) {
+                log.debug(`WorkBuddy Centrifuge transient error: ${msg}`);
+            }
+            else {
+                log.error(`WorkBuddy Centrifuge error: ${msg}`);
+            }
             updateState('error');
         },
         onPersistentFailure: () => {

package/dist/workbuddy/event-handler.js

@@ -4,15 +4,12 @@
 import { sendTextReply, sendErrorReply } from './message-sender.js';
 import { startTaskCleanup } from '../shared/task-cleanup.js';
 import { WORKBUDDY_THROTTLE_MS } from '../constants.js';
-import { setActiveChatId } from '../shared/active-chats.js';
-import { setChatUser } from '../shared/chat-user-map.js';
 import { createLogger } from '../logger.js';
 import { createPlatformEventContext } from '../platform/create-event-context.js';
 import { createPlatformAIRequestHandler } from '../platform/handle-ai-request.js';
+import { handleTextFlow } from '../platform/handle-text-flow.js';
 const log = createLogger('WorkBuddyHandler');
 export function setupWorkBuddyHandlers(config, sessionManager) {
-    // WorkBuddy-specific: taskKeyByChatId map for tracking
-    const taskKeyByChatId = new Map();
     // Create shared platform event context
     const ctx = createPlatformEventContext({
         platform: 'workbuddy',
@@ -21,7 +18,6 @@ export function setupWorkBuddyHandlers(config, sessionManager) {
         sessionManager,
         sender: {
             sendTextReply: async (chatId, text) => {
-                // WorkBuddy needs msgId for all replies, we'll handle this per-event
                 await sendTextReply(null, chatId, text, '');
             },
         },
@@ -31,157 +27,65 @@ export function setupWorkBuddyHandlers(config, sessionManager) {
     // WorkBuddy-specific sender callbacks (no thinking message needed)
     const platformSender = {
         sendThinkingMessage: async (_chatId, _replyToMessageId, _toolId) => {
-            // WorkBuddy uses incoming msgId as thinking message ID
-            // This is a no-op since we'll use the incoming msgId
+            // WorkBuddy uses incoming msgId directly; no separate thinking message
             return 'workbuddy_no_thinking';
         },
-        sendTextReply: async (_chatId, text) => {
-            // WorkBuddy-specific reply (needs msgId captured per event)
-            await sendTextReply(null, _chatId, text, '');
+        sendTextReply: async (chatId, text) => {
+            await sendTextReply(null, chatId, text, '');
         },
         startTyping: (_chatId) => {
             // WorkBuddy doesn't support typing indicators
             return () => { };
         },
     };
-    // WorkBuddy-specific callbacks (log-only streaming, no real updates)
-    const workBuddyTaskCallbacks = {
-        streamUpdate: async (content) => {
-            // WorkBuddy doesn't support streaming updates via Centrifuge
-            log.debug(`Stream update (not sent): ${content.substring(0, 50)}...`);
-        },
-        sendComplete: async (_content) => {
-            // Will be handled per-event with correct msgId
-        },
-        sendError: async (_error) => {
-            // Will be handled per-event with correct msgId
-        },
-        extraCleanup: () => {
-            // Clean up taskKeyByChatId on completion
-        },
-    };
-    // WorkBuddy-specific init to capture msgId for task tracking
-    const extraInit = ({ chatId, taskKey }) => {
-        taskKeyByChatId.set(chatId, taskKey);
-        return () => {
-            if (taskKeyByChatId.get(chatId) === taskKey) {
-                taskKeyByChatId.delete(chatId);
-            }
-        };
-    };
-    // Create platform-specific AI request handler
-    // Note: WorkBuddy uses a different handleAIRequest signature with msgId
-    // We'll need to wrap the standard handler
-    createPlatformAIRequestHandler({
-        platform: 'workbuddy',
-        config,
-        sessionManager,
-        sender: platformSender,
-        throttleMs: WORKBUDDY_THROTTLE_MS,
-        runningTasks: ctx.runningTasks,
-        taskCallbacks: workBuddyTaskCallbacks,
-        extraInit,
-    });
-    // WorkBuddy-specific wrapper that captures msgId
-    async function handleAIRequest(userId, chatId, msgId, prompt, workDir, convId, signal) {
-        log.info(`[AI_REQUEST] userId=${userId}, chatId=${chatId}, msgId=${msgId}, promptLength=${prompt.length}`);
-        // WorkBuddy uses incoming msgId as taskKey (no thinking message needed)
-        const taskKey = `${userId}:${msgId}`;
-        // Directly run AI task (WorkBuddy doesn't use the standard flow)
-        const { resolvePlatformAiCommand } = await import('../config.js');
-        const { getAdapter } = await import('../adapters/registry.js');
-        const { runAITask } = await import('../shared/ai-task.js');
-        const aiCommand = resolvePlatformAiCommand(config, 'workbuddy');
-        const toolAdapter = getAdapter(aiCommand);
-        if (!toolAdapter) {
-            log.error(`[handleAIRequest] No adapter found for: ${aiCommand}`);
-            await sendErrorReply(null, chatId, `AI tool is not configured: ${aiCommand}`, msgId);
-            return;
-        }
-        const sessionId = convId
-            ? sessionManager.getSessionIdForConv(userId, convId, aiCommand)
-            : undefined;
-        log.info(`[handleAIRequest] Running ${aiCommand} for user ${userId}, sessionId=${sessionId ?? 'new'}`);
-        // Set up task tracking key mapping
-        taskKeyByChatId.set(chatId, taskKey);
-        await runAITask({ config, sessionManager }, { userId, chatId, workDir, sessionId, convId, platform: 'workbuddy', taskKey, signal }, prompt, toolAdapter, {
-            throttleMs: WORKBUDDY_THROTTLE_MS,
-            streamUpdate: async (content) => {
-                log.debug(`Stream update (not sent): ${content.substring(0, 50)}...`);
-            },
-            sendComplete: async (content) => {
-                await sendTextReply(null, chatId, content, msgId);
-            },
-            sendError: async (error) => {
-                await sendErrorReply(null, chatId, error, msgId);
-            },
-            extraCleanup: () => {
-                ctx.runningTasks.delete(taskKey);
-                if (taskKeyByChatId.get(chatId) === taskKey) {
-                    taskKeyByChatId.delete(chatId);
-                }
-            },
-            onTaskReady: (state) => {
-                ctx.runningTasks.set(taskKey, state);
-                taskKeyByChatId.set(chatId, taskKey);
-            },
-        });
-    }
     async function handleEvent(chatId, msgId, content) {
         log.info(`[handleEvent] chatId=${chatId}, msgId=${msgId}, content="${content.substring(0, 100)}"`);
         // Use chatId as userId for WorkBuddy (WeChat KF doesn't have separate userId)
         const userId = chatId;
         const text = content.trim();
-        // Access control check
-        if (!ctx.accessControl.isAllowed(userId)) {
-            log.warn(`Access denied for sender: ${userId}`);
-            await sendErrorReply(null, chatId, `抱歉，您没有访问权限。\n您的 ID: ${userId}`, msgId);
-            return;
-        }
-        setActiveChatId('workbuddy', chatId);
-        setChatUser(chatId, userId, 'workbuddy');
-        const workDir = sessionManager.getWorkDir(userId);
-        const convId = sessionManager.getConvId(userId);
-        // Create a per-event sender that captures msgId
-        const eventSender = {
+        // Create a per-event sender that captures msgId for all replies
+        const msgIdSender = {
+            ...platformSender,
             sendTextReply: async (c, t) => {
                 await sendTextReply(null, c, t, msgId);
             },
         };
-        // Create a per-event CommandHandler with msgId-capturing sender
-        const { CommandHandler } = await import('../commands/handler.js');
-        const commandHandler = new CommandHandler({
+        // Create per-event handleAIRequest that captures msgId for task callbacks
+        const handleAIRequest = createPlatformAIRequestHandler({
+            platform: 'workbuddy',
             config,
             sessionManager,
-            requestQueue: ctx.requestQueue,
-            sender: eventSender,
-            getRunningTasksSize: () => ctx.runningTasks.size,
+            sender: msgIdSender,
+            throttleMs: WORKBUDDY_THROTTLE_MS,
+            runningTasks: ctx.runningTasks,
+            taskKeyBuilder: (userId, _msgId) => `${userId}:${msgId}`,
+            taskCallbacksFactory: ({ chatId: c }) => ({
+                streamUpdate: async () => {
+                    // WorkBuddy doesn't support streaming updates via Centrifuge
+                },
+                sendComplete: async (content) => {
+                    await sendTextReply(null, c, content, msgId);
+                },
+                sendError: async (error) => {
+                    await sendErrorReply(null, c, error, msgId);
+                },
+            }),
         });
-        // Try command handler first
-        try {
-            const handled = await commandHandler.dispatch(text, chatId, userId, 'workbuddy', (u, c, p, w, conv, _r, _m) => handleAIRequest(u, c, msgId, p, w, conv));
-            if (handled) {
-                log.info(`Command handled for message: ${text}`);
-                return;
-            }
-        }
-        catch (err) {
-            log.error('Error in commandHandler.dispatch:', err);
-        }
-        // No command, proceed with AI request
-        if (!text) {
-            return;
-        }
-        const enqueueResult = ctx.requestQueue.enqueue(userId, convId, text, async (nextPrompt, signal) => {
-            log.info(`Executing AI request for: ${nextPrompt}`);
-            await handleAIRequest(userId, chatId, msgId, nextPrompt, workDir, convId, signal);
+        // Use shared text flow with customEnqueue to carry msgId through
+        await handleTextFlow({
+            platform: 'workbuddy',
+            userId,
+            chatId,
+            text,
+            ctx,
+            handleAIRequest,
+            sendTextReply: (c, t) => sendTextReply(null, c, t, msgId),
+            workDir: sessionManager.getWorkDir(userId),
+            convId: sessionManager.getConvId(userId),
+            accessDeniedMessage: (uid) => `抱歉，您没有访问权限。\n您的 ID: ${uid}`,
+            queueFullMessage: '请求队列已满，请稍后再试。',
+            queuedMessage: '您的请求已排队等待。',
         });
-        if (enqueueResult === 'rejected') {
-            await sendErrorReply(null, chatId, '请求队列已满，请稍后再试。', msgId);
-        }
-        else if (enqueueResult === 'queued') {
-            await sendTextReply(null, chatId, '您的请求已排队等待。', msgId);
-        }
     }
     return {
         stop: () => stopTaskCleanup(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.10.2-beta.0",
+  "version": "1.10.2-beta.2",
   "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, CodeBuddy)",
   "type": "module",
   "main": "dist/index.js",