evolclaw 2.0.0

package/dist/core/message-cache.js

@@ -0,0 +1,56 @@
+/**
+ * 消息缓存
+ * 用于缓存后台任务的关键事件（完成、错误）
+ */
+export class MessageCache {
+    cache = new Map();
+    /**
+     * 添加事件到缓存
+     */
+    addEvent(sessionId, event) {
+        if (!this.cache.has(sessionId)) {
+            this.cache.set(sessionId, []);
+        }
+        this.cache.get(sessionId).push(event);
+    }
+    /**
+     * 获取指定会话的所有缓存事件
+     */
+    getEvents(sessionId) {
+        return this.cache.get(sessionId) || [];
+    }
+    /**
+     * 获取指定会话的缓存事件数量
+     */
+    getCount(sessionId) {
+        return this.cache.get(sessionId)?.length || 0;
+    }
+    /**
+     * 检查指定会话是否有缓存事件
+     */
+    hasMessages(sessionId) {
+        return this.getCount(sessionId) > 0;
+    }
+    /**
+     * 清空指定会话的缓存事件
+     */
+    clearEvents(sessionId) {
+        this.cache.delete(sessionId);
+    }
+    /**
+     * 清理过期的缓存事件
+     * @param maxAge 最大保留时间（毫秒），默认 72 小时
+     */
+    cleanupExpired(maxAge = 72 * 60 * 60 * 1000) {
+        const now = Date.now();
+        for (const [sessionId, events] of this.cache.entries()) {
+            const filtered = events.filter(e => now - e.timestamp < maxAge);
+            if (filtered.length === 0) {
+                this.cache.delete(sessionId);
+            }
+            else {
+                this.cache.set(sessionId, filtered);
+            }
+        }
+    }
+}

package/dist/core/message-processor.js

@@ -0,0 +1,516 @@
+import path from 'path';
+import fs from 'fs';
+import { StreamFlusher } from '../utils/stream-flusher.js';
+import { StreamIdleMonitor } from '../utils/stream-idle-monitor.js';
+import { logger } from '../utils/logger.js';
+import { getErrorMessage, classifyError, ErrorType } from '../utils/error-utils.js';
+import { isOwner } from '../config.js';
+/**
+ * 统一消息处理器
+ * 负责处理来自不同渠道的消息，协调事件流处理
+ */
+export class MessageProcessor {
+    agentRunner;
+    sessionManager;
+    config;
+    messageCache;
+    commandHandler;
+    channels = new Map();
+    currentFlusher;
+    currentIsGroup = false;
+    constructor(agentRunner, sessionManager, config, messageCache, commandHandler) {
+        this.agentRunner = agentRunner;
+        this.sessionManager = sessionManager;
+        this.config = config;
+        this.messageCache = messageCache;
+        this.commandHandler = commandHandler;
+    }
+    /**
+     * 注册渠道适配器
+     */
+    registerChannel(adapter, options) {
+        this.channels.set(adapter.name, { adapter, options });
+    }
+    /**
+     * 处理 compact 开始事件
+     */
+    handleCompactStart() {
+        if (this.currentFlusher && !this.currentIsGroup) {
+            this.currentFlusher.addActivity('⏳ 会话压缩中...');
+        }
+    }
+    /**
+     * 处理消息（主入口）
+     */
+    async processMessage(message) {
+        const isGroup = message.isGroup ?? false;
+        this.currentIsGroup = isGroup;
+        const idleMs = this.config.timeout?.idle ?? 120000;
+        const streamKey = `${message.channel}-${message.channelId}`;
+        const channelInfo = this.channels.get(message.channel);
+        const monitorEnabled = this.config.idleMonitor?.enabled !== false;
+        const safeModeThreshold = this.config.idleMonitor?.safeModeThreshold ?? 3;
+        const isOwnerUser = isOwner(this.config, message.channel, message.userId || '');
+        // 非主人（群聊或单聊）：空闲监控静默/简短
+        const quietMode = isGroup || !isOwnerUser;
+        let monitor;
+        let monitorInterval;
+        let rejectFn;
+        const resetTimer = (eventType, toolName) => {
+            monitor?.recordEvent(eventType || 'unknown', toolName);
+        };
+        const timeoutPromise = new Promise((_, reject) => {
+            rejectFn = reject;
+            if (!monitorEnabled)
+                return;
+            monitor = new StreamIdleMonitor(idleMs);
+            monitorInterval = setInterval(async () => {
+                // Drain all pending levels in one tick
+                let result = monitor.check();
+                while (result) {
+                    if (result.action === 'kill') {
+                        logger.warn(`[MessageProcessor] Idle monitor: kill after ${result.idleSec}s idle, stream: ${streamKey}`);
+                        // 先发送诊断信息，让用户知道发生了什么
+                        if (channelInfo) {
+                            try {
+                                const msg = quietMode
+                                    ? `⚠️ 任务超时（${result.idleSec}秒无响应），已自动中断`
+                                    : result.message;
+                                await channelInfo.adapter.sendText(message.channelId, msg);
+                            }
+                            catch (e) {
+                                logger.debug(`[MessageProcessor] Failed to send kill diagnostic message:`, e);
+                            }
+                        }
+                        try {
+                            await this.agentRunner.interrupt(streamKey);
+                        }
+                        catch (e) {
+                            logger.debug(`[MessageProcessor] Interrupt failed (may already be cleaned up):`, e);
+                        }
+                        rejectFn(new Error('SDK_TIMEOUT'));
+                        return;
+                    }
+                    else {
+                        // notify or warn: send diagnostic message, task continues（非主人时静默）
+                        logger.info(`[MessageProcessor] Idle monitor: ${result.action} after ${result.idleSec}s idle, stream: ${streamKey}`);
+                        if (channelInfo && !quietMode) {
+                            try {
+                                await channelInfo.adapter.sendText(message.channelId, result.message);
+                            }
+                            catch (e) {
+                                logger.debug(`[MessageProcessor] Failed to send idle monitor message:`, e);
+                            }
+                        }
+                    }
+                    result = monitor.check();
+                }
+            }, 30000);
+        });
+        try {
+            await Promise.race([
+                this._processMessageInternal(message, resetTimer),
+                timeoutPromise
+            ]);
+        }
+        catch (error) {
+            // 超时错误：kill 级别已发送诊断信息，无需再发
+            // 非超时错误走通用处理
+            // 记录错误到健康状态（仅主人的错误累计触发安全模式）
+            if (channelInfo) {
+                try {
+                    const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.config.projects?.defaultPath || process.cwd());
+                    const errorType = classifyError(error);
+                    // 上下文过长是可恢复错误，不累计触发安全模式
+                    if (errorType === ErrorType.CONTEXT_TOO_LONG) {
+                        logger.info(`[MessageProcessor] Context too long error, skipping safe mode accumulation`);
+                    }
+                    else if (quietMode) {
+                        // 群聊或非主人的错误只记日志，不累计
+                        logger.info(`[MessageProcessor] Non-owner/group error (user=${message.userId}, group=${isGroup}), skipping safe mode accumulation`);
+                    }
+                    else {
+                        const newCount = await this.sessionManager.recordError(session.id, errorType, error.message);
+                        await this.checkSafeMode(session.id, message.channelId, channelInfo.adapter, safeModeThreshold, newCount);
+                    }
+                }
+                catch (statusError) {
+                    logger.error('[MessageProcessor] Failed to update health status:', statusError);
+                }
+            }
+            throw error;
+        }
+        finally {
+            if (monitorInterval)
+                clearInterval(monitorInterval);
+        }
+    }
+    /**
+     * 检查是否需要进入安全模式（safeModeThreshold 为 0 时跳过）
+     * 仅单聊主人会话调用（群聊和非主人已在调用侧过滤）
+     */
+    async checkSafeMode(sessionId, channelId, adapter, safeModeThreshold, consecutiveErrors) {
+        if (safeModeThreshold <= 0)
+            return;
+        const health = await this.sessionManager.getHealthStatus(sessionId);
+        if (consecutiveErrors >= safeModeThreshold && !health.safeMode) {
+            await this.sessionManager.setSafeMode(sessionId, true);
+            logger.warn(`[MessageProcessor] Session ${sessionId} entered safe mode after ${consecutiveErrors} errors`);
+            await adapter.sendText(channelId, `⚠️ 安全模式已启用（连续 ${consecutiveErrors} 次异常）
+
+当前限制：
+- 无法记住之前的对话
+- 每次提问需要提供完整上下文
+
+建议操作：
+1. /repair - 检查并修复会话（推荐，保留历史）
+2. /new [名称] - 创建新会话（清空历史）
+3. /status - 查看详细状态`);
+        }
+        else if (safeModeThreshold >= 2 && consecutiveErrors === safeModeThreshold - 1) {
+            // 阈值前一次错误，发送警告
+            await adapter.sendText(channelId, `⚠️ 检测到异常（${consecutiveErrors}/${safeModeThreshold}）\n\n如果问题持续，系统将自动进入安全模式。建议使用 /status 查看状态。`);
+        }
+    }
+    async _processMessageInternal(message, resetTimer) {
+        const messageId = `${message.channel}_${message.channelId}_${message.timestamp || Date.now()}`;
+        const channelInfo = this.channels.get(message.channel);
+        if (!channelInfo) {
+            logger.error(`[MessageProcessor] Unknown channel: ${message.channel}`);
+            return;
+        }
+        const { adapter, options } = channelInfo;
+        try {
+            // 检查是否为命令
+            if (this.commandHandler) {
+                const cmdResult = await this.commandHandler(message.content, message.channel, message.channelId, message.userId);
+                if (cmdResult) {
+                    await adapter.sendText(message.channelId, cmdResult);
+                    return;
+                }
+            }
+            // 解析会话和项目路径
+            const { session, absoluteProjectPath } = await this.resolveSession(message);
+            // 判断是否是后台任务
+            const activeSession = await this.sessionManager.getActiveSession(message.channel, message.channelId);
+            const isBackground = activeSession ? session.id !== activeSession.id : false;
+            // 记录收到消息
+            logger.message({
+                msgId: messageId,
+                sessionId: session.id,
+                dir: 'inbound',
+                status: 'received'
+            });
+            const imageInfo = message.images && message.images.length > 0 ? ` [${message.images.length} image(s)]` : '';
+            const modeInfo = isBackground ? ' [后台]' : '';
+            logger.info(`[${message.channel}] ${message.channelId}: ${message.content}${imageInfo}${modeInfo}`);
+            // 记录开始处理
+            logger.message({
+                msgId: messageId,
+                sessionId: session.id,
+                dir: 'inbound',
+                status: 'processing'
+            });
+            const startTime = Date.now();
+            // 创建 StreamFlusher，传入文件标记模式用于自动过滤
+            // 使用动态判断，确保切换项目后不会继续输出
+            let firstReply = true;
+            const flusher = new StreamFlusher(async (text, isFinal) => {
+                // 动态判断是否是后台任务
+                const currentActiveSession = await this.sessionManager.getActiveSession(message.channel, message.channelId);
+                const isCurrentlyBackground = currentActiveSession ? session.id !== currentActiveSession.id : false;
+                if (!isCurrentlyBackground) {
+                    const opts = {};
+                    if (isFinal)
+                        opts.title = '最终回复:';
+                    // 首条消息引用回复用户原消息
+                    if (firstReply && message.messageId) {
+                        opts.replyToMessageId = message.messageId;
+                        firstReply = false;
+                    }
+                    await adapter.sendText(message.channelId, text, Object.keys(opts).length ? opts : undefined);
+                }
+                // 后台任务：静默，不发送输出
+            }, this.config.flushDelay ?? 4000, options?.fileMarkerPattern);
+            // 保存当前 flusher，用于 compact 事件
+            this.currentFlusher = flusher;
+            // 调用 AgentRunner（含上下文过长自动 compact 重试）
+            const streamKey = `${message.channel}-${message.channelId}`;
+            try {
+                const stream = await this.agentRunner.runQuery(session.id, message.content, absoluteProjectPath, session.claudeSessionId, message.images, options?.systemPromptAppend, this.sessionManager);
+                this.agentRunner.registerStream(streamKey, stream);
+                await this.processEventStream(stream, session, message.channelId, adapter, options, flusher, isBackground, resetTimer);
+            }
+            catch (error) {
+                if (this.isContextTooLongError(error) && session.claudeSessionId) {
+                    // 尝试 compact 压缩会话
+                    flusher.addActivity('⚠️ 上下文过长，正在压缩会话...');
+                    await flusher.flush();
+                    const compacted = await this.agentRunner.compactSession(session.id, session.claudeSessionId, absoluteProjectPath);
+                    if (compacted) {
+                        // compact 成功，带 resume 重试
+                        flusher.addActivity('✅ 压缩完成，正在重试...');
+                        const retryStream = await this.agentRunner.runQuery(session.id, message.content, absoluteProjectPath, session.claudeSessionId, message.images, options?.systemPromptAppend, this.sessionManager);
+                        this.agentRunner.registerStream(streamKey, retryStream);
+                        await this.processEventStream(retryStream, session, message.channelId, adapter, options, flusher, isBackground, resetTimer);
+                    }
+                    else {
+                        throw new Error('CONTEXT_COMPACT_FAILED');
+                    }
+                }
+                else {
+                    throw error;
+                }
+            }
+            // 处理文件标记（Feishu 专用）- 提取并发送文件
+            if (options?.fileMarkerPattern && adapter.sendFile) {
+                const fullText = flusher.getFinalText();
+                const fileMatches = [...fullText.matchAll(options.fileMarkerPattern)];
+                for (const match of fileMatches) {
+                    const filePath = match[1].trim();
+                    const resolvedPath = this.resolveFilePath(filePath, absoluteProjectPath);
+                    logger.info(`[${adapter.name}] Sending file: ${resolvedPath}`);
+                    try {
+                        await adapter.sendFile(message.channelId, resolvedPath);
+                    }
+                    catch (error) {
+                        logger.error(`[${adapter.name}] Failed to send file: ${resolvedPath}`, error);
+                        await adapter.sendText(message.channelId, `❌ 文件发送失败: ${filePath}`);
+                    }
+                }
+            }
+            // Flush 剩余内容（文件标记已在 flush 时自动移除）
+            await flusher.flush(true);
+            // 安全模式尾部提示：如果当前会话处于安全模式，追加提醒
+            const healthStatus = await this.sessionManager.getHealthStatus(session.id);
+            if (healthStatus.safeMode) {
+                await adapter.sendText(message.channelId, '\n\n⚠️ 当前处于安全模式（无上下文记忆）。使用 /repair 修复 或 /new 新建会话');
+            }
+            // 清理 activeStreams（正常完成）
+            this.agentRunner.cleanupStream(streamKey);
+            // 记录成功响应（重置错误计数）
+            await this.sessionManager.recordSuccess(session.id);
+            // 动态判断是否是后台任务，决定是否发送通知
+            const currentActive = await this.sessionManager.getActiveSession(message.channel, message.channelId);
+            const isFinallyBackground = currentActive ? session.id !== currentActive.id : false;
+            if (isFinallyBackground) {
+                const projectName = path.basename(session.projectPath);
+                const count = this.messageCache.getCount(session.id);
+                await adapter.sendText(message.channelId, `[后台-${projectName}] ✓ 任务完成 (${count}条消息已缓存)`);
+            }
+            const duration = Date.now() - startTime;
+            // 记录处理完成
+            logger.message({
+                msgId: messageId,
+                sessionId: session.id,
+                dir: 'inbound',
+                status: 'completed',
+                duration
+            });
+            // 记录发送响应
+            logger.message({
+                msgId: `${messageId}_reply`,
+                sessionId: session.id,
+                dir: 'outbound',
+                status: 'sent'
+            });
+        }
+        catch (error) {
+            logger.error(`[${message.channel}] Error:`, error);
+            // 记录处理失败
+            logger.message({
+                msgId: messageId,
+                sessionId: message.channelId,
+                dir: 'inbound',
+                status: 'failed',
+                error: error instanceof Error ? error.message : String(error)
+            });
+            if (error instanceof Error) {
+                logger.error(`[${message.channel}] Error stack:`, error.stack);
+            }
+            // 发送用户友好的错误消息（SDK_TIMEOUT 已在 kill 级别发过提示，跳过）
+            if (error instanceof Error && error.message === 'SDK_TIMEOUT') {
+                logger.info(`[MessageProcessor] SDK_TIMEOUT error, skip sending duplicate message`);
+            }
+            else {
+                const userMessage = getErrorMessage(error);
+                await adapter.sendText(message.channelId, userMessage);
+            }
+        }
+    }
+    /**
+     * 解析会话和项目路径
+     */
+    async resolveSession(message) {
+        const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.config.projects?.defaultPath || process.cwd());
+        const absoluteProjectPath = path.isAbsolute(session.projectPath)
+            ? session.projectPath
+            : path.resolve(process.cwd(), session.projectPath);
+        return { session, absoluteProjectPath };
+    }
+    /**
+     * 处理事件流
+     */
+    async processEventStream(stream, session, channelId, adapter, options, flusher, isBackground, resetTimer) {
+        let hasTextDelta = false;
+        let hasReceivedText = false;
+        let lastSessionId;
+        try {
+            for await (const event of stream) {
+                // 每收到事件重置空闲超时，传入事件类型和工具名
+                const toolName = event.type === 'assistant'
+                    ? event.message?.content?.find((c) => c.type === 'tool_use')?.name
+                    : undefined;
+                resetTimer(event.type, toolName);
+                // 记录所有事件类型（INFO级别，便于诊断）
+                logger.info(`[MessageProcessor] Event: type=${event.type}, subtype=${event.subtype || 'none'}`);
+                // 提取 session_id（只在首次或变化时更新）
+                if (event.session_id && event.session_id !== lastSessionId) {
+                    logger.info(`[MessageProcessor] Extracted session_id: ${event.session_id} for session: ${session.id}`);
+                    this.agentRunner.updateSessionId(session.id, event.session_id);
+                    lastSessionId = event.session_id;
+                }
+                // 动态判断当前是否是后台任务
+                const currentActive = await this.sessionManager.getActiveSession(session.channel, session.channelId);
+                const isCurrentlyBackground = currentActive ? session.id !== currentActive.id : false;
+                // === 前台任务：正常处理所有事件 ===
+                if (!isCurrentlyBackground) {
+                    // 流式文本事件
+                    if (event.type === 'text_delta' && event.text) {
+                        hasTextDelta = true;
+                        hasReceivedText = true;
+                        flusher.addText(event.text);
+                    }
+                    // 系统事件：compact_boundary（群聊时静默）
+                    if (event.type === 'system' && event.subtype === 'compact_boundary') {
+                        if (!this.currentIsGroup) {
+                            const preTokens = event.compact_metadata?.pre_tokens || 0;
+                            flusher.addActivity(`💡 会话压缩完成，继续执行...（压缩前 tokens: ${preTokens}）`);
+                        }
+                    }
+                    // 系统事件：task_progress（子任务进度）
+                    if (event.type === 'system' && event.subtype === 'task_progress') {
+                        const tools = event.tool_uses ?? 0;
+                        const duration = event.duration_ms ? `${Math.round(event.duration_ms / 1000)}s` : '';
+                        const summary = event.summary;
+                        const stats = [tools > 0 ? `${tools}次工具调用` : '', duration].filter(Boolean).join(', ');
+                        if (summary) {
+                            flusher.addActivity(`⏳ 子任务: ${summary}${stats ? ` (${stats})` : ''}`);
+                        }
+                        else if (stats) {
+                            flusher.addActivity(`⏳ 子任务进行中: ${stats}`);
+                        }
+                    }
+                    // Assistant 事件：提取工具调用和文本内容
+                    if (event.type === 'assistant' && event.message?.content) {
+                        for (const content of event.message.content) {
+                            if (content.type === 'tool_use') {
+                                const desc = this.formatToolDescription(content);
+                                flusher.addActivity(`🔧 ${content.name}${desc ? ': ' + desc : ''}`);
+                            }
+                            else if (content.type === 'text' && content.text && !hasTextDelta) {
+                                // 仅在没有 text_delta 事件时从 assistant 事件提取文本，避免重复
+                                hasReceivedText = true;
+                                flusher.addTextBlock(content.text);
+                            }
+                        }
+                    }
+                    // 工具结果事件：显示失败信息（包括权限拒绝、执行失败等所有场景）
+                    if (event.type === 'tool_result') {
+                        logger.debug(`[MessageProcessor] tool_result: is_error=${event.is_error}, error=${event.error}, content=${typeof event.content}`);
+                        if (event.is_error) {
+                            const toolName = event.tool_name || '工具';
+                            const errorMsg = event.error || (typeof event.content === 'string' ? event.content : JSON.stringify(event.content)) || '执行失败';
+                            flusher.addActivity(`⚠️ ${toolName}: ${errorMsg}`);
+                        }
+                    }
+                    // Result 事件：仅在没有流式文本时使用 result 作为最终输出
+                    if (event.type === 'result' && event.result) {
+                        logger.debug(`[MessageProcessor] result event: hasReceivedText=${hasReceivedText}, result="${event.result}"`);
+                        if (!hasReceivedText) {
+                            // 没有通过 text_delta 或 assistant 收到文本，使用 result 作为兜底
+                            flusher.addText(event.result);
+                        }
+                        await flusher.flush();
+                    }
+                    continue;
+                }
+                // === 后台任务：只处理 result 事件，仅缓存不发送 ===
+                if (event.type !== 'result') {
+                    continue;
+                }
+                if (event.subtype === 'success') {
+                    this.messageCache.addEvent(session.id, {
+                        type: 'completed',
+                        message: event.result,
+                        timestamp: Date.now(),
+                        metadata: {
+                            duration: event.duration_ms,
+                            cost: event.total_cost_usd
+                        }
+                    });
+                }
+                else if (event.is_error === true) {
+                    this.messageCache.addEvent(session.id, {
+                        type: 'error',
+                        message: event.errors?.join('\n') || '未知错误',
+                        timestamp: Date.now(),
+                        metadata: {
+                            errorType: event.subtype
+                        }
+                    });
+                }
+            }
+        }
+        catch (error) {
+            // 捕获 SDK 进程崩溃或流迭代错误
+            logger.error('[MessageProcessor] Stream processing error:', error);
+            if (error instanceof Error && error.message.includes('process exited')) {
+                flusher.addActivity('❌ Claude Code 进程异常退出，请重试');
+            }
+            throw error; // 重新抛出，让外层处理
+        }
+    }
+    /**
+     * 判断是否为上下文过长错误
+     */
+    isContextTooLongError(error) {
+        const msg = (error?.message || String(error)).toLowerCase();
+        return msg.includes('上下文过长') || msg.includes('context too long')
+            || msg.includes('context_length_exceeded');
+    }
+    /**
+     * 格式化工具描述（通用）
+     */
+    formatToolDescription(toolUse) {
+        const input = toolUse.input || {};
+        return (input.description ||
+            input.file_path ||
+            input.pattern ||
+            (typeof input.command === 'string' ? input.command.substring(0, 80) : undefined) ||
+            (typeof input.prompt === 'string' ? input.prompt.substring(0, 80) : undefined) ||
+            (typeof input.query === 'string' ? input.query.substring(0, 80) : undefined) ||
+            '');
+    }
+    /**
+     * 解析文件路径，支持相对路径和绝对路径
+     * 优先在项目根目录查找，兜底尝试 .openclaw/workspace/
+     */
+    resolveFilePath(filePath, projectPath) {
+        if (path.isAbsolute(filePath)) {
+            return filePath;
+        }
+        // 优先在项目根目录查找
+        const rootPath = path.join(projectPath, filePath);
+        if (fs.existsSync(rootPath)) {
+            return rootPath;
+        }
+        // 兜底：尝试 .openclaw/workspace/
+        const workspacePath = path.join(projectPath, '.openclaw', 'workspace', filePath);
+        if (fs.existsSync(workspacePath)) {
+            return workspacePath;
+        }
+        // 都找不到，返回项目根目录路径
+        return rootPath;
+    }
+}

package/dist/core/message-queue.js

@@ -0,0 +1,110 @@
+import path from 'path';
+import { logger } from '../utils/logger.js';
+export class MessageQueue {
+    queues = new Map();
+    processing = new Set();
+    handler;
+    currentSessionKey;
+    currentProjectPath;
+    interruptCallback;
+    constructor(handler) {
+        this.handler = handler;
+    }
+    setInterruptCallback(callback) {
+        this.interruptCallback = callback;
+    }
+    /**
+     * 生成项目级别的队列 key
+     */
+    getQueueKey(sessionKey, projectPath) {
+        const projectName = path.basename(projectPath);
+        return `${sessionKey}-${projectName}`;
+    }
+    async enqueue(sessionKey, message, projectPath) {
+        const queueKey = this.getQueueKey(sessionKey, projectPath);
+        logger.debug(`[Queue] Enqueuing message for ${queueKey}`);
+        return new Promise((resolve, reject) => {
+            if (!this.queues.has(queueKey)) {
+                this.queues.set(queueKey, []);
+            }
+            this.queues.get(queueKey).push({ message, projectPath, resolve, reject });
+            // 如果正在处理，触发中断
+            if (this.processing.has(queueKey)) {
+                logger.debug(`[Queue] ${queueKey} is processing, triggering interrupt`);
+                if (this.interruptCallback) {
+                    this.interruptCallback(sessionKey).catch(() => { });
+                }
+            }
+            else {
+                logger.debug(`[Queue] Starting to process ${queueKey}`);
+                this.processNext(queueKey);
+            }
+        });
+    }
+    async processNext(queueKey) {
+        this.processing.add(queueKey);
+        logger.debug(`[Queue] Processing queue ${queueKey}`);
+        while (true) {
+            const queue = this.queues.get(queueKey);
+            if (!queue || queue.length === 0) {
+                logger.debug(`[Queue] Queue ${queueKey} is empty, stopping`);
+                this.processing.delete(queueKey);
+                this.currentSessionKey = undefined;
+                this.currentProjectPath = undefined;
+                return;
+            }
+            const { message, projectPath, resolve, reject } = queue.shift();
+            this.currentSessionKey = queueKey;
+            this.currentProjectPath = projectPath;
+            logger.debug(`[Queue] Processing message from ${message.channel}:${message.channelId}`);
+            try {
+                await this.handler(message);
+                logger.debug(`[Queue] Message processed successfully`);
+                resolve();
+            }
+            catch (error) {
+                logger.error(`[Queue] Message processing failed:`, error);
+                reject(error);
+            }
+        }
+    }
+    getQueueLength(sessionKey) {
+        // 计算该 sessionKey 下所有项目队列的总长度
+        let total = 0;
+        for (const [key, queue] of this.queues.entries()) {
+            if (key.startsWith(sessionKey + '-')) {
+                total += queue.length;
+            }
+        }
+        return total;
+    }
+    isProcessing(sessionKey) {
+        // 检查该 sessionKey 下是否有任何项目队列在处理
+        for (const key of this.processing.keys()) {
+            if (key.startsWith(sessionKey + '-')) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * 获取正在处理的项目路径
+     */
+    getProcessingProject(sessionKey) {
+        // 查找该 sessionKey 下正在处理的项目
+        for (const key of this.processing.keys()) {
+            if (key.startsWith(sessionKey + '-')) {
+                // 从 processing 中找到对应的队列，获取 projectPath
+                const queue = this.queues.get(key);
+                if (queue && queue.length > 0) {
+                    return queue[0].projectPath;
+                }
+                // 如果队列为空但仍在处理，返回当前正在处理的项目路径
+                if (this.currentSessionKey === key) {
+                    return this.currentProjectPath;
+                }
+            }
+        }
+        return undefined;
+    }
+}