@tencent-connect/openclaw-qqbot 1.6.4-alpha.4 → 1.6.4-alpha.6

package/dist/src/gateway.js

@@ -314,10 +314,12 @@ function markStartupGreetingSent(version) {
 }
 function markStartupGreetingFailed(version, reason) {
     const marker = readStartupMarker();
+    // 同版本已有失败记录时，不覆盖 lastFailureAt，避免冷却期被无限续期
+    const shouldPreserveTimestamp = marker.lastFailureVersion === version && marker.lastFailureAt;
     writeStartupMarker({
         ...marker,
         lastFailureVersion: version,
-        lastFailureAt: new Date().toISOString(),
+        lastFailureAt: shouldPreserveTimestamp ? marker.lastFailureAt : new Date().toISOString(),
         lastFailureReason: reason,
     });
 }
@@ -435,8 +437,13 @@ export async function startGateway(ctx) {
         try {
             if (fs.existsSync(UPGRADE_GREETING_TARGET_FILE)) {
                 const data = JSON.parse(fs.readFileSync(UPGRADE_GREETING_TARGET_FILE, "utf8"));
-                if (data.openid)
-                    return data.openid;
+                if (!data.openid)
+                    return undefined;
+                if (data.appId && data.appId !== account.appId)
+                    return undefined;
+                if (data.accountId && data.accountId !== account.accountId)
+                    return undefined;
+                return data.openid;
             }
         }
         catch { /* 文件损坏视为无 */ }
@@ -590,11 +597,12 @@ export async function startGateway(ctx) {
         finally {
             activeUsers.delete(peerId);
             userQueues.delete(peerId);
-            // 处理完后，检查是否有等待并发槽位的用户
+            // 处理完后，唤醒等待的用户填满并发槽位
             for (const [waitingPeerId, waitingQueue] of userQueues) {
+                if (activeUsers.size >= MAX_CONCURRENT_USERS)
+                    break; // 槽位已满
                 if (waitingQueue.length > 0 && !activeUsers.has(waitingPeerId)) {
                     drainUserQueue(waitingPeerId);
-                    break; // 每次只唤醒一个，避免瞬间并发激增
                 }
             }
         }
@@ -777,33 +785,35 @@ export async function startGateway(ctx) {
                     accountId: account.accountId,
                     direction: "inbound",
                 });
-                // 发送输入状态提示（非关键，失败不影响主流程）
-                // 同时从响应中获取 ref_idx，用于缓存入站消息
-                let inputNotifyRefIdx;
-                try {
-                    let token = await getAccessToken(account.appId, account.clientSecret);
+                // 发送输入状态提示（fire-and-forget：不阻塞主流程）
+                // refIdx 通过 Promise 延迟获取，在真正需要时再 await
+                const inputNotifyPromise = (async () => {
                     try {
-                        const notifyResponse = await sendC2CInputNotify(token, event.senderId, event.messageId, 60);
-                        inputNotifyRefIdx = notifyResponse.refIdx;
-                    }
-                    catch (notifyErr) {
-                        const errMsg = String(notifyErr);
-                        if (errMsg.includes("token") || errMsg.includes("401") || errMsg.includes("11244")) {
-                            log?.info(`[qqbot:${account.accountId}] InputNotify token expired, refreshing...`);
-                            clearTokenCache(account.appId);
-                            token = await getAccessToken(account.appId, account.clientSecret);
+                        let token = await getAccessToken(account.appId, account.clientSecret);
+                        try {
                             const notifyResponse = await sendC2CInputNotify(token, event.senderId, event.messageId, 60);
-                            inputNotifyRefIdx = notifyResponse.refIdx;
+                            log?.info(`[qqbot:${account.accountId}] Sent input notify to ${event.senderId}${notifyResponse.refIdx ? `, got refIdx=${notifyResponse.refIdx}` : ""}`);
+                            return notifyResponse.refIdx;
                         }
-                        else {
-                            throw notifyErr;
+                        catch (notifyErr) {
+                            const errMsg = String(notifyErr);
+                            if (errMsg.includes("token") || errMsg.includes("401") || errMsg.includes("11244")) {
+                                log?.info(`[qqbot:${account.accountId}] InputNotify token expired, refreshing...`);
+                                clearTokenCache(account.appId);
+                                token = await getAccessToken(account.appId, account.clientSecret);
+                                const notifyResponse = await sendC2CInputNotify(token, event.senderId, event.messageId, 60);
+                                return notifyResponse.refIdx;
+                            }
+                            else {
+                                throw notifyErr;
+                            }
                         }
                     }
-                    log?.info(`[qqbot:${account.accountId}] Sent input notify to ${event.senderId}${inputNotifyRefIdx ? `, got refIdx=${inputNotifyRefIdx}` : ""}`);
-                }
-                catch (err) {
-                    log?.error(`[qqbot:${account.accountId}] sendC2CInputNotify error: ${err}`);
-                }
+                    catch (err) {
+                        log?.error(`[qqbot:${account.accountId}] sendC2CInputNotify error: ${err}`);
+                        return undefined;
+                    }
+                })();
                 const isGroupChat = event.type === "guild" || event.type === "group";
                 // peerId 只放纯 ID，类型信息由 peer.kind 表达
                 // 群聊：用 groupOpenid（框架根据 kind:"group" 区分）
@@ -845,24 +855,15 @@ export async function startGateway(ctx) {
                 const downloadDir = getQQBotDataDir("downloads");
                 if (event.attachments?.length) {
                     const otherAttachments = [];
-                    for (const att of event.attachments) {
-                        // 修复 QQ 返回的 // 前缀 URL
+                    // Phase 1: 并行下载所有附件
+                    const downloadTasks = event.attachments.map(async (att) => {
                         const attUrl = att.url?.startsWith("//") ? `https:${att.url}` : att.url;
-                        // 语音附件：优先下载 WAV（voice_wav_url），减少 SILK→WAV 转换
                         const isVoice = isVoiceAttachment(att);
-                        const asrReferText = typeof att.asr_refer_text === "string" ? att.asr_refer_text.trim() : "";
                         const wavUrl = isVoice && att.voice_wav_url
                             ? (att.voice_wav_url.startsWith("//") ? `https:${att.voice_wav_url}` : att.voice_wav_url)
                             : "";
-                        const voiceSourceUrl = wavUrl || attUrl;
-                        if (isVoice) {
-                            if (voiceSourceUrl)
-                                voiceAttachmentUrls.push(voiceSourceUrl);
-                            if (asrReferText)
-                                voiceAsrReferTexts.push(asrReferText);
-                        }
                         let localPath = null;
-                        let audioPath = null; // 用于 STT 的音频路径
+                        let audioPath = null;
                         if (isVoice && wavUrl) {
                             const wavLocalPath = await downloadFile(wavUrl, downloadDir);
                             if (wavLocalPath) {
@@ -874,114 +875,146 @@ export async function startGateway(ctx) {
                                 log?.error(`[qqbot:${account.accountId}] Failed to download voice_wav_url, falling back to original URL`);
                             }
                         }
-                        // WAV 下载失败或不是语音附件：下载原始文件
                         if (!localPath) {
                             localPath = await downloadFile(attUrl, downloadDir, att.filename);
                         }
+                        return { att, attUrl, isVoice, localPath, audioPath };
+                    });
+                    const downloadResults = await Promise.all(downloadTasks);
+                    // Phase 2: 并行处理语音转换+转录（非语音附件同步归类）
+                    const processTasks = downloadResults.map(async ({ att, attUrl, isVoice, localPath, audioPath }) => {
+                        const asrReferText = typeof att.asr_refer_text === "string" ? att.asr_refer_text.trim() : "";
+                        const wavUrl = isVoice && att.voice_wav_url
+                            ? (att.voice_wav_url.startsWith("//") ? `https:${att.voice_wav_url}` : att.voice_wav_url)
+                            : "";
+                        const voiceSourceUrl = wavUrl || attUrl;
+                        // 收集语音元数据（顺序无关）
+                        const meta = {
+                            voiceUrl: isVoice && voiceSourceUrl ? voiceSourceUrl : undefined,
+                            asrReferText: isVoice && asrReferText ? asrReferText : undefined,
+                        };
                         if (localPath) {
                             if (att.content_type?.startsWith("image/")) {
-                                imageUrls.push(localPath);
-                                imageMediaTypes.push(att.content_type);
+                                log?.info(`[qqbot:${account.accountId}] Downloaded attachment to: ${localPath}`);
+                                return { localPath, type: "image", contentType: att.content_type, meta };
                             }
                             else if (isVoice) {
-                                voiceAttachmentPaths.push(localPath);
-                                // 语音消息处理：先检查 STT 是否可用，避免无意义的转换开销
+                                log?.info(`[qqbot:${account.accountId}] Downloaded attachment to: ${localPath}`);
+                                // 语音处理：转换 + 转录
                                 const sttCfg = resolveSTTConfig(cfg);
                                 if (!sttCfg) {
                                     if (asrReferText) {
                                         log?.info(`[qqbot:${account.accountId}] Voice attachment: ${att.filename} (STT not configured, using asr_refer_text fallback)`);
-                                        voiceTranscripts.push(asrReferText);
-                                        voiceTranscriptSources.push("asr");
+                                        return { localPath, type: "voice", transcript: asrReferText, transcriptSource: "asr", meta };
                                     }
                                     else {
                                         log?.info(`[qqbot:${account.accountId}] Voice attachment: ${att.filename} (STT not configured, skipping transcription)`);
-                                        voiceTranscripts.push("[语音消息 - 语音识别未配置，无法转录]");
-                                        voiceTranscriptSources.push("fallback");
+                                        return { localPath, type: "voice", transcript: "[语音消息 - 语音识别未配置，无法转录]", transcriptSource: "fallback", meta };
                                     }
                                 }
-                                else {
-                                    // 如果还没有 WAV 路径（voice_wav_url 不可用），需要 SILK→WAV 转换
-                                    if (!audioPath) {
-                                        const sttFormats = account.config?.audioFormatPolicy?.sttDirectFormats;
-                                        log?.info(`[qqbot:${account.accountId}] Voice attachment: ${att.filename}, converting SILK→WAV...`);
-                                        try {
-                                            const wavResult = await convertSilkToWav(localPath, downloadDir);
-                                            if (wavResult) {
-                                                audioPath = wavResult.wavPath;
-                                                log?.info(`[qqbot:${account.accountId}] Voice converted: ${wavResult.wavPath} (${formatDuration(wavResult.duration)})`);
-                                            }
-                                            else {
-                                                audioPath = localPath; // 转换失败，尝试用原始文件
-                                            }
-                                        }
-                                        catch (convertErr) {
-                                            log?.error(`[qqbot:${account.accountId}] Voice conversion failed: ${convertErr}`);
-                                            if (asrReferText) {
-                                                log?.info(`[qqbot:${account.accountId}] Voice attachment: ${att.filename} (using asr_refer_text fallback after convert failure)`);
-                                                voiceTranscripts.push(asrReferText);
-                                                voiceTranscriptSources.push("asr");
-                                            }
-                                            else {
-                                                voiceTranscripts.push("[语音消息 - 格式转换失败]");
-                                                voiceTranscriptSources.push("fallback");
-                                            }
-                                            continue;
-                                        }
-                                    }
-                                    // STT 转录
+                                // SILK→WAV 转换
+                                if (!audioPath) {
+                                    log?.info(`[qqbot:${account.accountId}] Voice attachment: ${att.filename}, converting SILK→WAV...`);
                                     try {
-                                        const transcript = await transcribeAudio(audioPath, cfg);
-                                        if (transcript) {
-                                            log?.info(`[qqbot:${account.accountId}] STT transcript: ${transcript.slice(0, 100)}...`);
-                                            voiceTranscripts.push(transcript);
-                                            voiceTranscriptSources.push("stt");
-                                        }
-                                        else if (asrReferText) {
-                                            log?.info(`[qqbot:${account.accountId}] STT returned empty result, using asr_refer_text fallback`);
-                                            voiceTranscripts.push(asrReferText);
-                                            voiceTranscriptSources.push("asr");
+                                        const wavResult = await convertSilkToWav(localPath, downloadDir);
+                                        if (wavResult) {
+                                            audioPath = wavResult.wavPath;
+                                            log?.info(`[qqbot:${account.accountId}] Voice converted: ${wavResult.wavPath} (${formatDuration(wavResult.duration)})`);
                                         }
                                         else {
-                                            log?.info(`[qqbot:${account.accountId}] STT returned empty result`);
-                                            voiceTranscripts.push("[语音消息 - 转录结果为空]");
-                                            voiceTranscriptSources.push("fallback");
+                                            audioPath = localPath;
                                         }
                                     }
-                                    catch (sttErr) {
-                                        log?.error(`[qqbot:${account.accountId}] STT failed: ${sttErr}`);
+                                    catch (convertErr) {
+                                        log?.error(`[qqbot:${account.accountId}] Voice conversion failed: ${convertErr}`);
                                         if (asrReferText) {
-                                            log?.info(`[qqbot:${account.accountId}] Voice attachment: ${att.filename} (using asr_refer_text fallback after STT failure)`);
-                                            voiceTranscripts.push(asrReferText);
-                                            voiceTranscriptSources.push("asr");
+                                            return { localPath, type: "voice", transcript: asrReferText, transcriptSource: "asr", meta };
                                         }
                                         else {
-                                            voiceTranscripts.push("[语音消息 - 转录失败]");
-                                            voiceTranscriptSources.push("fallback");
+                                            return { localPath, type: "voice", transcript: "[语音消息 - 格式转换失败]", transcriptSource: "fallback", meta };
                                         }
                                     }
                                 }
+                                // STT 转录
+                                try {
+                                    const transcript = await transcribeAudio(audioPath, cfg);
+                                    if (transcript) {
+                                        log?.info(`[qqbot:${account.accountId}] STT transcript: ${transcript.slice(0, 100)}...`);
+                                        return { localPath, type: "voice", transcript, transcriptSource: "stt", meta };
+                                    }
+                                    else if (asrReferText) {
+                                        log?.info(`[qqbot:${account.accountId}] STT returned empty result, using asr_refer_text fallback`);
+                                        return { localPath, type: "voice", transcript: asrReferText, transcriptSource: "asr", meta };
+                                    }
+                                    else {
+                                        log?.info(`[qqbot:${account.accountId}] STT returned empty result`);
+                                        return { localPath, type: "voice", transcript: "[语音消息 - 转录结果为空]", transcriptSource: "fallback", meta };
+                                    }
+                                }
+                                catch (sttErr) {
+                                    log?.error(`[qqbot:${account.accountId}] STT failed: ${sttErr}`);
+                                    if (asrReferText) {
+                                        return { localPath, type: "voice", transcript: asrReferText, transcriptSource: "asr", meta };
+                                    }
+                                    else {
+                                        return { localPath, type: "voice", transcript: "[语音消息 - 转录失败]", transcriptSource: "fallback", meta };
+                                    }
+                                }
                             }
                             else {
-                                otherAttachments.push(`[附件: ${localPath}]`);
+                                log?.info(`[qqbot:${account.accountId}] Downloaded attachment to: ${localPath}`);
+                                return { localPath, type: "other", filename: att.filename, meta };
                             }
-                            log?.info(`[qqbot:${account.accountId}] Downloaded attachment to: ${localPath}`);
-                            attachmentLocalPaths.push(localPath);
                         }
                         else {
-                            // 下载失败，fallback 到原始 URL
                             log?.error(`[qqbot:${account.accountId}] Failed to download: ${attUrl}`);
                             if (att.content_type?.startsWith("image/")) {
-                                imageUrls.push(attUrl);
-                                imageMediaTypes.push(att.content_type);
+                                return { localPath: null, type: "image-fallback", attUrl, contentType: att.content_type, meta };
                             }
                             else if (isVoice && asrReferText) {
                                 log?.info(`[qqbot:${account.accountId}] Voice attachment download failed, using asr_refer_text fallback`);
-                                voiceTranscripts.push(asrReferText);
-                                voiceTranscriptSources.push("asr");
+                                return { localPath: null, type: "voice-fallback", transcript: asrReferText, meta };
                             }
                             else {
-                                otherAttachments.push(`[附件: ${att.filename ?? att.content_type}] (下载失败)`);
+                                return { localPath: null, type: "other-fallback", filename: att.filename ?? att.content_type, meta };
                             }
+                        }
+                    });
+                    const processResults = await Promise.all(processTasks);
+                    // Phase 3: 按原始顺序归类结果（保持与附件数组一一对应）
+                    for (const result of processResults) {
+                        // 收集语音元数据
+                        if (result.meta.voiceUrl)
+                            voiceAttachmentUrls.push(result.meta.voiceUrl);
+                        if (result.meta.asrReferText)
+                            voiceAsrReferTexts.push(result.meta.asrReferText);
+                        if (result.type === "image" && result.localPath) {
+                            imageUrls.push(result.localPath);
+                            imageMediaTypes.push(result.contentType);
+                            attachmentLocalPaths.push(result.localPath);
+                        }
+                        else if (result.type === "voice" && result.localPath) {
+                            voiceAttachmentPaths.push(result.localPath);
+                            voiceTranscripts.push(result.transcript);
+                            voiceTranscriptSources.push(result.transcriptSource);
+                            attachmentLocalPaths.push(result.localPath);
+                        }
+                        else if (result.type === "other" && result.localPath) {
+                            otherAttachments.push(`[附件: ${result.localPath}]`);
+                            attachmentLocalPaths.push(result.localPath);
+                        }
+                        else if (result.type === "image-fallback") {
+                            imageUrls.push(result.attUrl);
+                            imageMediaTypes.push(result.contentType);
+                            attachmentLocalPaths.push(null);
+                        }
+                        else if (result.type === "voice-fallback") {
+                            voiceTranscripts.push(result.transcript);
+                            voiceTranscriptSources.push("asr");
+                            attachmentLocalPaths.push(null);
+                        }
+                        else if (result.type === "other-fallback") {
+                            otherAttachments.push(`[附件: ${result.filename}] (下载失败)`);
                             attachmentLocalPaths.push(null);
                         }
                     }
@@ -1026,6 +1059,8 @@ export async function startGateway(ctx) {
                 }
                 // 2. 缓存当前消息自身的 msgIdx（供将来被引用时查找）
                 // 优先使用推送事件中的 msgIdx（来自 message_scene.ext），否则使用 InputNotify 返回的 refIdx
+                // inputNotifyPromise 在这里才 await，此时附件下载等工作已并行完成
+                const inputNotifyRefIdx = await inputNotifyPromise;
                 const currentMsgIdx = event.msgIdx ?? inputNotifyRefIdx;
                 if (currentMsgIdx) {
                     const attSummaries = buildAttachmentSummaries(event.attachments, attachmentLocalPaths);

package/dist/src/slash-commands.js

@@ -206,12 +206,16 @@ function findBash() {
     }
 }
 /**
- * 执行热更新：执行脚本(--no-restart) → 触发 gateway restart
+ * 执行热更新：执行脚本(--no-restart) → 立即触发 gateway restart
  *
  * fire-and-forget 操作：
  * - 异步执行升级脚本（--no-restart，只做文件替换）
- * - 脚本完成后触发 gateway restart（当前进程会被杀掉）
+ * - 脚本完成后**立即**触发 gateway restart（当前进程会被杀掉）
  * - 新进程启动时 getStartupGreeting() 检测到版本变更，自动通知管理员
+ *
+ * 注意：gateway restart 必须在文件替换完成后尽快执行，
+ * 否则 openclaw 的配置热加载轮询（~1s）会不断检测到插件目录
+ * 已变更但进程未重启，从而产生 "plugin not found" warning 刷屏。
  */
 function fireHotUpgrade(targetVersion) {
     const scriptPath = getUpgradeScriptPath();
@@ -228,12 +232,28 @@ function fireHotUpgrade(targetVersion) {
         timeout: 120_000,
         env: { ...process.env },
         ...(isWindows() ? { windowsHide: true } : {}),
-    }, (error, _stdout, _stderr) => {
+    }, (error, stdout, _stderr) => {
         if (error) {
             return;
         }
-        // 文件替换成功，触发 gateway restart
-        execFile(cli, ["gateway", "restart"], { timeout: 30_000 }, () => { });
+        // 从脚本输出中提取版本号，验证文件替换是否成功
+        const versionMatch = stdout.match(/QQBOT_NEW_VERSION=(\S+)/);
+        const newVersion = versionMatch?.[1];
+        if (newVersion === "unknown") {
+            // 文件替换异常，不执行 restart 以保持现有服务
+            return;
+        }
+        // 文件替换成功，立即触发 gateway restart（不再等后续步骤）
+        execFile(cli, ["gateway", "restart"], { timeout: 30_000 }, (restartErr) => {
+            if (restartErr) {
+                // restart 失败，尝试 stop + start 作为 fallback
+                execFile(cli, ["gateway", "stop"], { timeout: 10_000 }, () => {
+                    setTimeout(() => {
+                        execFile(cli, ["gateway", "start"], { timeout: 30_000 }, () => { });
+                    }, 1000);
+                });
+            }
+        });
     });
     return { ok: true };
 }
@@ -326,104 +346,161 @@ registerCommand({
 /**
  * /bot-logs — 导出本地日志文件
  *
- * 日志路径检测策略（兼容特殊安装路径和 --profile/--dev 模式）：
- * 1. OPENCLAW_STATE_DIR 环境变量指定的目录
- * 2. 扫描 home 目录下所有 .openclaw-xxx/logs/ 目录，取最近修改的 gateway.log
+ * 日志定位策略（兼容腾讯云/各云厂商不同安装路径）：
+ * 1. 优先使用 *_STATE_DIR 环境变量（OPENCLAW/CLAWDBOT/MOLTBOT）
+ * 2. 扫描常见状态目录：~/.openclaw, ~/.clawdbot, ~/.moltbot 及其 logs 子目录
+ * 3. 扫描 home/cwd/AppData 下名称包含 openclaw/clawdbot/moltbot 的目录
+ * 4. 在候选目录中选取最近更新的日志文件（gateway/openclaw/clawdbot/moltbot）
  */
-registerCommand({
-    name: "bot-logs",
-    description: "导出本地日志文件",
-    handler: () => {
-        const homeDir = getHomeDir();
-        // 收集所有可能的日志目录
-        const logDirs = [];
-        // 优先：环境变量指定的状态目录
-        const stateDir = process.env.OPENCLAW_STATE_DIR;
-        if (stateDir) {
-            logDirs.push(path.join(stateDir, "logs"));
+function collectCandidateLogDirs() {
+    const homeDir = getHomeDir();
+    const dirs = new Set();
+    const pushDir = (p) => {
+        if (!p)
+            return;
+        const normalized = path.resolve(p);
+        dirs.add(normalized);
+    };
+    const pushStateDir = (stateDir) => {
+        if (!stateDir)
+            return;
+        pushDir(stateDir);
+        pushDir(path.join(stateDir, "logs"));
+    };
+    for (const [key, value] of Object.entries(process.env)) {
+        if (!value)
+            continue;
+        if (/STATE_DIR$/i.test(key) && /(OPENCLAW|CLAWDBOT|MOLTBOT)/i.test(key)) {
+            pushStateDir(value);
         }
-        // 扫描搜索根目录列表（兼容 Windows APPDATA 路径）
-        const searchRoots = new Set([homeDir]);
-        const appData = process.env.APPDATA; // Windows: C:\Users\xxx\AppData\Roaming
-        if (appData)
-            searchRoots.add(appData);
-        const localAppData = process.env.LOCALAPPDATA; // Windows: C:\Users\xxx\AppData\Local
-        if (localAppData)
-            searchRoots.add(localAppData);
-        for (const root of searchRoots) {
-            try {
-                const entries = fs.readdirSync(root, { withFileTypes: true });
-                for (const entry of entries) {
-                    if (entry.isDirectory() && (entry.name.startsWith(".openclaw") || entry.name.startsWith("openclaw"))) {
-                        const candidate = path.join(root, entry.name, "logs");
-                        if (!logDirs.includes(candidate)) {
-                            logDirs.push(candidate);
-                        }
-                    }
-                }
-            }
-            catch {
-                // 无权限或不存在，跳过
+    }
+    for (const name of [".openclaw", ".clawdbot", ".moltbot", "openclaw", "clawdbot", "moltbot"]) {
+        pushDir(path.join(homeDir, name));
+        pushDir(path.join(homeDir, name, "logs"));
+    }
+    const searchRoots = new Set([
+        homeDir,
+        process.cwd(),
+        path.dirname(process.cwd()),
+    ]);
+    if (process.env.APPDATA)
+        searchRoots.add(process.env.APPDATA);
+    if (process.env.LOCALAPPDATA)
+        searchRoots.add(process.env.LOCALAPPDATA);
+    for (const root of searchRoots) {
+        try {
+            const entries = fs.readdirSync(root, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                if (!/(openclaw|clawdbot|moltbot)/i.test(entry.name))
+                    continue;
+                const base = path.join(root, entry.name);
+                pushDir(base);
+                pushDir(path.join(base, "logs"));
             }
         }
-        // 兜底：默认路径
-        const defaultLogDir = path.join(homeDir, ".openclaw", "logs");
-        if (!logDirs.includes(defaultLogDir)) {
-            logDirs.push(defaultLogDir);
+        catch {
+            // 无权限或不存在，跳过
         }
-        // 从所有候选目录中找到存在且最近修改的 gateway.log
-        let bestLogDir = null;
-        let bestMtime = 0;
-        for (const logDir of logDirs) {
-            const gatewayLog = path.join(logDir, "gateway.log");
-            try {
-                const stat = fs.statSync(gatewayLog);
-                if (stat.mtimeMs > bestMtime) {
-                    bestMtime = stat.mtimeMs;
-                    bestLogDir = logDir;
-                }
-            }
-            catch {
-                // 不存在或无权限，跳过
+    }
+    return Array.from(dirs);
+}
+function collectRecentLogFiles(logDirs) {
+    const candidates = [];
+    const dedupe = new Set();
+    const pushFile = (filePath, sourceDir) => {
+        const normalized = path.resolve(filePath);
+        if (dedupe.has(normalized))
+            return;
+        try {
+            const stat = fs.statSync(normalized);
+            if (!stat.isFile())
+                return;
+            dedupe.add(normalized);
+            candidates.push({ filePath: normalized, sourceDir, mtimeMs: stat.mtimeMs });
+        }
+        catch {
+            // 文件不存在或无权限
+        }
+    };
+    for (const dir of logDirs) {
+        pushFile(path.join(dir, "gateway.log"), dir);
+        pushFile(path.join(dir, "gateway.err.log"), dir);
+        pushFile(path.join(dir, "openclaw.log"), dir);
+        pushFile(path.join(dir, "clawdbot.log"), dir);
+        pushFile(path.join(dir, "moltbot.log"), dir);
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isFile())
+                    continue;
+                if (!/\.(log|txt)$/i.test(entry.name))
+                    continue;
+                if (!/(gateway|openclaw|clawdbot|moltbot)/i.test(entry.name))
+                    continue;
+                pushFile(path.join(dir, entry.name), dir);
             }
         }
-        if (!bestLogDir) {
+        catch {
+            // 无权限或不存在，跳过
+        }
+    }
+    candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return candidates;
+}
+registerCommand({
+    name: "bot-logs",
+    description: "导出本地日志文件",
+    handler: () => {
+        const logDirs = collectCandidateLogDirs();
+        const recentFiles = collectRecentLogFiles(logDirs).slice(0, 4);
+        if (recentFiles.length === 0) {
             const searched = logDirs.map(d => `  - ${d}`).join("\n");
             return `⚠️ 未找到日志文件\n\n已搜索以下路径：\n${searched}`;
         }
-        const gatewayLog = path.join(bestLogDir, "gateway.log");
-        const errLog = path.join(bestLogDir, "gateway.err.log");
         const lines = [];
-        for (const logFile of [gatewayLog, errLog]) {
-            if (!fs.existsSync(logFile))
-                continue;
+        let totalIncluded = 0;
+        let totalOriginal = 0;
+        let truncatedCount = 0;
+        const MAX_LINES_PER_FILE = 1000;
+        for (const logFile of recentFiles) {
             try {
-                const content = fs.readFileSync(logFile, "utf8");
+                const content = fs.readFileSync(logFile.filePath, "utf8");
                 const allLines = content.split("\n");
-                const tail = allLines.slice(-1000);
+                const totalFileLines = allLines.length;
+                const tail = allLines.slice(-MAX_LINES_PER_FILE);
                 if (tail.length > 0) {
-                    lines.push(`\n========== ${path.basename(logFile)} (last ${tail.length} lines) ==========\n`);
+                    const fileName = path.basename(logFile.filePath);
+                    lines.push(`\n========== ${fileName} (last ${tail.length} of ${totalFileLines} lines) ==========`);
+                    lines.push(`from: ${logFile.sourceDir}`);
                     lines.push(...tail);
+                    totalIncluded += tail.length;
+                    totalOriginal += totalFileLines;
+                    if (totalFileLines > MAX_LINES_PER_FILE)
+                        truncatedCount++;
                 }
             }
             catch {
-                lines.push(`[读取 ${path.basename(logFile)} 失败]`);
+                lines.push(`[读取 ${path.basename(logFile.filePath)} 失败]`);
             }
         }
         if (lines.length === 0) {
-            return `⚠️ 日志文件为空（路径：${bestLogDir}）`;
-        }
-        // 写入临时文件
-        const tmpDir = path.join(homeDir, ".openclaw", "qqbot", "downloads");
-        if (!fs.existsSync(tmpDir)) {
-            fs.mkdirSync(tmpDir, { recursive: true });
+            return `⚠️ 找到日志文件但读取失败，请检查文件权限`;
         }
+        const tmpDir = getQQBotDataDir("downloads");
         const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
         const tmpFile = path.join(tmpDir, `bot-logs-${timestamp}.txt`);
         fs.writeFileSync(tmpFile, lines.join("\n"), "utf8");
-        const totalLines = lines.filter(l => !l.startsWith("=")).length;
+        const fileCount = recentFiles.length;
+        const topSources = Array.from(new Set(recentFiles.map(item => item.sourceDir))).slice(0, 3);
+        // 紧凑摘要：N 个日志文件，共 X 行（如有截断则注明）
+        let summaryText = `${fileCount} 个日志文件，共 ${totalIncluded} 行`;
+        if (truncatedCount > 0) {
+            summaryText += `（${truncatedCount} 个文件因过长仅保留最后 ${MAX_LINES_PER_FILE} 行，原始共 ${totalOriginal} 行）`;
+        }
         return {
-            text: `📋 日志已打包（约 ${totalLines} 行），正在发送文件...\n📂 来源：${bestLogDir}`,
+            text: `📋 ${summaryText}\n📂 来源：${topSources.join(" | ")}`,
             filePath: tmpFile,
         };
     },