evolclaw 2.1.2 → 2.3.0

package/dist/core/message/message-queue.js

@@ -0,0 +1,240 @@
+import path from 'path';
+import { logger } from '../../utils/logger.js';
+export class MessageQueue {
+    queues = new Map();
+    processing = new Set();
+    externalLocks = new Map();
+    handler;
+    currentSessionKey;
+    currentProjectPath;
+    currentAgentId;
+    interruptCallback;
+    eventBus;
+    recentMessageIds = new Set();
+    DEDUP_WINDOW = 60_000; // 1 分钟窗口
+    constructor(handler) {
+        this.handler = handler;
+    }
+    setInterruptCallback(callback) {
+        this.interruptCallback = callback;
+    }
+    setEventBus(eventBus) {
+        this.eventBus = eventBus;
+    }
+    /**
+     * 检查消息是否应该处理（去重）
+     */
+    shouldProcess(message) {
+        if (!message.messageId)
+            return true; // 无 ID 的消息不去重
+        if (this.recentMessageIds.has(message.messageId)) {
+            logger.debug(`[Queue] Duplicate message ${message.messageId}, skipping`);
+            return false;
+        }
+        this.recentMessageIds.add(message.messageId);
+        setTimeout(() => this.recentMessageIds.delete(message.messageId), this.DEDUP_WINDOW);
+        return true;
+    }
+    /**
+     * 检查队列 key 是否属于指定 sessionKey
+     */
+    matchesSession(key, sessionKey) {
+        return key.startsWith(sessionKey + '::');
+    }
+    /**
+     * 生成项目级别的队列 key
+     */
+    getQueueKey(sessionKey, projectPath) {
+        const normalized = projectPath ? path.resolve(projectPath) : '';
+        return `${sessionKey}::${normalized}`;
+    }
+    async enqueue(sessionKey, message, projectPath, options) {
+        // 消息去重检查
+        if (!this.shouldProcess(message)) {
+            return Promise.resolve();
+        }
+        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 });
+            // 根据 interruptible 选项决定是否触发中断
+            if (this.processing.has(queueKey)) {
+                if (options?.interruptible !== false) {
+                    // 单聊：保留中断行为
+                    logger.debug(`[Queue] ${queueKey} is processing, triggering interrupt`);
+                    this.eventBus?.publish({ type: 'message:interrupted', sessionId: sessionKey, reason: 'new_message' });
+                    if (this.interruptCallback) {
+                        this.interruptCallback(sessionKey, this.currentAgentId).catch(() => { });
+                    }
+                }
+                else {
+                    // 群聊：FIFO，不打断
+                    logger.debug(`[Queue] ${queueKey} is processing, message queued (FIFO)`);
+                }
+            }
+            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) {
+            // 等待外部锁释放（/compact, /clear 等快速命令）
+            const lock = this.getExternalLock(queueKey);
+            if (lock) {
+                logger.debug(`[Queue] Waiting for external lock on ${queueKey}`);
+                await lock;
+            }
+            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;
+            }
+            // FIFO 贪心合并：弹出队首连续同 peerId 的消息
+            const items = this.dequeueGreedy(queue);
+            const merged = items.length === 1 ? items[0] : this.mergeItems(items);
+            this.currentSessionKey = queueKey;
+            this.currentProjectPath = merged.projectPath;
+            this.currentAgentId = merged.message.agentId;
+            const resolves = items.map(i => i.resolve);
+            const rejects = items.map(i => i.reject);
+            logger.debug(`[Queue] Processing ${items.length} message(s) from ${merged.message.channel}:${merged.message.channelId}`);
+            try {
+                await this.handler(merged.message);
+                logger.debug(`[Queue] Message processed successfully`);
+                resolves.forEach(r => r());
+            }
+            catch (error) {
+                logger.error(`[Queue] Message processing failed:`, error);
+                rejects.forEach(r => r(error));
+            }
+        }
+    }
+    /**
+     * 贪心弹出队首连续同 peerId 的消息。
+     * 遇到不同 peerId 或队列为空时停止。
+     */
+    dequeueGreedy(queue) {
+        const first = queue.shift();
+        const result = [first];
+        const peerId = first.message.peerId;
+        while (queue.length > 0 && queue[0].message.peerId === peerId) {
+            result.push(queue.shift());
+        }
+        if (result.length > 1) {
+            logger.debug(`[Queue] Greedy dequeue: merged ${result.length} messages from peerId=${peerId}`);
+        }
+        return result;
+    }
+    /**
+     * 合并多条同 peerId 消息：
+     * - content: \n 连接
+     * - images / mentions: 扁平合并
+     * - messageId: 置空（合并后不代表某一条具体消息）
+     * - replyContext / peerName / 其余字段: 取最后一条
+     */
+    mergeItems(items) {
+        const contents = [];
+        const allImages = [];
+        const allMentions = [];
+        for (const item of items) {
+            const m = item.message;
+            contents.push(m.content);
+            if (m.images)
+                allImages.push(...m.images);
+            if (m.mentions)
+                allMentions.push(...m.mentions);
+        }
+        const last = items[items.length - 1];
+        const merged = {
+            ...last.message,
+            content: contents.join('\n'),
+            images: allImages.length > 0 ? allImages : undefined,
+            mentions: allMentions.length > 0 ? allMentions : undefined,
+            messageId: undefined,
+        };
+        return {
+            message: merged,
+            projectPath: last.projectPath,
+            resolve: () => { }, // 由调用方管理
+            reject: () => { },
+        };
+    }
+    getQueueLength(sessionKey) {
+        // 计算该 sessionKey 下所有项目队列的总长度
+        let total = 0;
+        for (const [key, queue] of this.queues.entries()) {
+            if (this.matchesSession(key, sessionKey)) {
+                total += queue.length;
+            }
+        }
+        return total;
+    }
+    isProcessing(sessionKey) {
+        // 检查该 sessionKey 下是否有任何项目队列在处理
+        for (const key of this.processing.keys()) {
+            if (this.matchesSession(key, sessionKey)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    cancel(messageId) {
+        for (const queue of this.queues.values()) {
+            const idx = queue.findIndex(q => q.message.messageId === messageId);
+            if (idx !== -1) {
+                const [removed] = queue.splice(idx, 1);
+                removed.resolve();
+                logger.info(`[Queue] Cancelled queued message ${messageId}`);
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * 外部锁：快速命令（/compact, /clear）执行期间阻塞队列处理
+     * 返回 release 函数
+     */
+    acquireLock(sessionKey) {
+        let releaseFn;
+        const promise = new Promise(resolve => { releaseFn = resolve; });
+        this.externalLocks.set(sessionKey, promise);
+        return () => {
+            this.externalLocks.delete(sessionKey);
+            releaseFn();
+        };
+    }
+    /** 检查是否有外部锁 */
+    getExternalLock(queueKey) {
+        for (const [key, promise] of this.externalLocks) {
+            if (this.matchesSession(queueKey, key))
+                return promise;
+        }
+        return undefined;
+    }
+    /**
+     * 获取全局队列长度（所有会话的待处理消息总数）
+     */
+    getGlobalQueueLength() {
+        let total = 0;
+        for (const queue of this.queues.values()) {
+            total += queue.length;
+        }
+        return total;
+    }
+    /**
+     * 获取全局处理中队列数量
+     */
+    getGlobalProcessingCount() {
+        return this.processing.size;
+    }
+}

package/dist/core/message/stream-debouncer.js

@@ -0,0 +1,122 @@
+import { logger } from '../../utils/logger.js';
+/**
+ * 入站消息去抖器
+ *
+ * 在 debounceMs 窗口内收到的同一 session 的多条消息合并为一次 enqueue：
+ * - content 用 \n 连接
+ * - images / mentions 合并
+ * - replyContext / 其余字段取最后一条
+ *
+ * cancel(messageId) 可精确移除窗口中的某条消息，不影响其余消息。
+ */
+export class StreamDebouncer {
+    pending = new Map();
+    delayMs;
+    maxWaitMs;
+    maxMessages;
+    constructor(debounceSeconds, maxMessages = 5) {
+        this.delayMs = debounceSeconds * 1000;
+        this.maxWaitMs = this.delayMs * 3;
+        this.maxMessages = maxMessages;
+    }
+    get enabled() {
+        return this.delayMs > 0;
+    }
+    /**
+     * 提交一条消息。如果窗口内已有消息则追加并重置 timer；
+     * 否则新建窗口。timer 到期后自动 flush。
+     */
+    submit(key, message, enqueue) {
+        const { content, images, mentions, messageId, replyContext, ...rest } = message;
+        return new Promise((resolve, reject) => {
+            const entry = { messageId, content, images, mentions, replyContext, rest, resolve, reject };
+            const win = this.pending.get(key);
+            if (win) {
+                clearTimeout(win.timer);
+                win.entries.push(entry);
+                if (win.entries.length >= this.maxMessages) {
+                    logger.debug(`[Debounce] Max messages (${this.maxMessages}) reached for ${key}, flushing immediately`);
+                    clearTimeout(win.maxWaitTimer);
+                    this.flush(key, enqueue);
+                    return;
+                }
+                win.timer = setTimeout(() => this.flush(key, enqueue), this.delayMs);
+                logger.debug(`[Debounce] Appended message for ${key}, ${win.entries.length} pending`);
+            }
+            else {
+                const timer = setTimeout(() => this.flush(key, enqueue), this.delayMs);
+                const maxWaitTimer = setTimeout(() => this.flush(key, enqueue), this.maxWaitMs);
+                this.pending.set(key, { entries: [entry], timer, maxWaitTimer });
+                logger.debug(`[Debounce] New window for ${key}, debounce=${this.delayMs}ms, maxWait=${this.maxWaitMs}ms`);
+            }
+        });
+    }
+    /**
+     * 从 debounce 窗口中撤回指定 messageId 的消息。
+     * 如果窗口只剩这一条，整个窗口取消。
+     * @returns true 如果找到并移除
+     */
+    cancel(messageId) {
+        for (const [key, win] of this.pending) {
+            const idx = win.entries.findIndex(e => e.messageId === messageId);
+            if (idx === -1)
+                continue;
+            // resolve 被撤回的那条（静默完成，不报错）
+            win.entries.splice(idx, 1)[0].resolve();
+            logger.info(`[Debounce] Cancelled message ${messageId} from window ${key}`);
+            // 窗口空了 → 整个取消
+            if (win.entries.length === 0) {
+                clearTimeout(win.timer);
+                clearTimeout(win.maxWaitTimer);
+                this.pending.delete(key);
+                logger.info(`[Debounce] Window ${key} empty after cancel, removed`);
+            }
+            return true;
+        }
+        return false;
+    }
+    flush(key, enqueue) {
+        const win = this.pending.get(key);
+        if (!win)
+            return;
+        this.pending.delete(key);
+        clearTimeout(win.timer);
+        clearTimeout(win.maxWaitTimer);
+        const { entries } = win;
+        // 合并：content 用 \n 连接，images/mentions 扁平合并，其余取最后一条
+        const allImages = [];
+        const allMentions = [];
+        const contents = [];
+        for (const e of entries) {
+            contents.push(e.content);
+            if (e.images)
+                allImages.push(...e.images);
+            if (e.mentions)
+                allMentions.push(...e.mentions);
+        }
+        const last = entries[entries.length - 1];
+        const merged = {
+            ...last.rest,
+            content: contents.join('\n'),
+            images: allImages.length > 0 ? allImages : undefined,
+            mentions: allMentions.length > 0 ? allMentions : undefined,
+            replyContext: last.replyContext,
+            messageId: entries.length > 1 ? undefined : last.messageId,
+        };
+        const resolves = entries.map(e => e.resolve);
+        const rejects = entries.map(e => e.reject);
+        enqueue(merged).then(() => resolves.forEach(r => r()), (e) => rejects.forEach(r => r(e)));
+    }
+    /** 当前挂起的 key 数量（用于测试/调试） */
+    get pendingCount() {
+        return this.pending.size;
+    }
+    /** 清理所有挂起的 timer（用于 shutdown） */
+    dispose() {
+        for (const win of this.pending.values()) {
+            clearTimeout(win.timer);
+            clearTimeout(win.maxWaitTimer);
+        }
+        this.pending.clear();
+    }
+}

package/dist/{utils → core/message}/stream-flusher.js

@@ -1,6 +1,7 @@
+import { logger } from '../../utils/logger.js';
 import fs from 'fs';
 import path from 'path';
-import { resolvePaths } from '../paths.js';
+import { resolvePaths } from '../../paths.js';
 // 诊断日志（按需启用，通过 config.debug.flusherDiag 控制）
 let diagStream = null;
 function getDiagStream() {
@@ -32,7 +33,7 @@ export class StreamFlusher {
     send;
     interval;
     buffer = '';
-    activities = [];
+    queue = []; // 按入队顺序记录 activity 和 text 段
     timer;
     lastFlush = Date.now();
     allText = '';
@@ -43,6 +44,7 @@ export class StreamFlusher {
     instanceId;
     createTime = Date.now();
     diagEnabled;
+    sendChain = Promise.resolve(); // 串行发送队列，保证消息按序到达
     constructor(send, interval = 4000, fileMarkerPattern, diagEnabled = false) {
         this.send = send;
         this.interval = interval;
@@ -53,11 +55,14 @@ export class StreamFlusher {
             diag(this.instanceId, 'created', { interval });
     }
     addText(text) {
+        if (this.buffer.length === 0 && text.length > 0) {
+            this.queue.push({ kind: 'text' });
+        }
         this.buffer += text;
         this.allText += text;
         this.messageTimestamps.push(Date.now());
         if (this.diagEnabled)
-            diag(this.instanceId, 'addText', { len: text.length, preview: text.substring(0, 60), bufLen: this.buffer.length, actCount: this.activities.length });
+            diag(this.instanceId, 'addText', { len: text.length, preview: text.substring(0, 60), bufLen: this.buffer.length, queueLen: this.queue.length });
         this.scheduleFlush();
     }
     addTextBlock(text) {
@@ -67,20 +72,21 @@ export class StreamFlusher {
         }
         this.buffer += text;
         this.allText += text;
+        this.queue.push({ kind: 'text' });
         this.messageTimestamps.push(Date.now());
         if (this.diagEnabled)
             diag(this.instanceId, 'addTextBlock', { len: text.length, preview: text.substring(0, 60), bufLen: this.buffer.length });
         this.scheduleFlush();
     }
     addActivity(desc) {
-        this.activities.push(desc);
+        this.queue.push({ kind: 'activity', text: desc });
         this.messageTimestamps.push(Date.now());
         if (this.diagEnabled)
-            diag(this.instanceId, 'addActivity', { desc: desc.substring(0, 80), actCount: this.activities.length });
+            diag(this.instanceId, 'addActivity', { desc: desc.substring(0, 80), queueLen: this.queue.length });
         this.scheduleFlush();
     }
     hasContent() {
-        return this.buffer.length > 0 || this.activities.length > 0;
+        return this.buffer.length > 0 || this.queue.some(e => e.kind === 'activity');
     }
     hasSentContent() {
         return this.sentContent;
@@ -102,7 +108,7 @@ export class StreamFlusher {
         }
         let targetDelay;
         if (this.flushCount === 0) {
-            targetDelay = 0;
+            targetDelay = 500;
         }
         else if (this.flushCount <= 3) {
             targetDelay = Math.ceil(this.interval / 2);
@@ -133,27 +139,81 @@ export class StreamFlusher {
         const maxDelay = this.interval * 2.5;
         return Math.max(minDelay, Math.min(maxDelay, dynamicDelay));
     }
+    /**
+     * 只 flush activities，保留 text buffer 不动
+     * 用于 complete 事件前清空 pending activities，让最终文本留给 flush(true) 发送
+     */
+    async flushActivitiesOnly() {
+        const hasActivities = this.queue.some(e => e.kind === 'activity');
+        if (!hasActivities)
+            return;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        // 只取 activity 条目，保留 text 条目在 queue 中
+        const activities = this.queue.filter(e => e.kind === 'activity');
+        this.queue = this.queue.filter(e => e.kind === 'text');
+        let output = activities.map(e => e.text).join('\n') + '\n\n';
+        if (output && this.fileMarkerPattern) {
+            output = output.replace(this.fileMarkerPattern, '').trim();
+        }
+        if (this.diagEnabled)
+            diag(this.instanceId, 'flushActivitiesOnly', { outputLen: output.length });
+        if (output) {
+            const text = output;
+            // chain 保持不断裂：单条失败不阻塞后续（catch → resolve）
+            this.sendChain = this.sendChain
+                .then(() => this.send(text, false, false))
+                .catch(e => { logger.warn('[StreamFlusher] send failed:', e); });
+            await this.sendChain;
+            this.sentContent = true;
+            this.lastFlush = Date.now();
+            this.flushCount++;
+        }
+    }
     async flush(isFinal) {
         if (this.timer) {
             clearTimeout(this.timer);
             this.timer = undefined;
         }
         let output = '';
-        if (this.activities.length > 0) {
-            output += this.activities.join('\n') + '\n\n';
-            this.activities = [];
+        const hasText = this.buffer.length > 0;
+        // 按入队顺序合并：遇到 text 条目时插入 buffer 内容，遇到 activity 直接追加
+        let textInserted = false;
+        for (const entry of this.queue) {
+            if (entry.kind === 'activity') {
+                // 确保 activity 前有换行分隔（text 末尾可能没有换行）
+                if (output && !output.endsWith('\n'))
+                    output += '\n';
+                output += entry.text + '\n';
+            }
+            else if (!textInserted) {
+                if (output)
+                    output += output.endsWith('\n') ? '\n' : '\n\n';
+                output += this.buffer;
+                textInserted = true;
+            }
         }
-        if (this.buffer) {
+        // 如果 queue 为空但有 buffer（纯文本情况）
+        if (!textInserted && hasText) {
             output += this.buffer;
-            this.buffer = '';
         }
+        this.queue = [];
+        this.buffer = '';
         if (output && this.fileMarkerPattern) {
             output = output.replace(this.fileMarkerPattern, '').trim();
         }
         if (this.diagEnabled)
             diag(this.instanceId, 'flush', { isFinal, outputLen: output.length, flushCount: this.flushCount, sinceLastFlush: Date.now() - this.lastFlush, preview: output.substring(0, 80) });
         if (output) {
-            await this.send(output, isFinal);
+            const text = output;
+            const final = isFinal;
+            const ht = hasText;
+            this.sendChain = this.sendChain
+                .then(() => this.send(text, final, ht))
+                .catch(e => { logger.warn('[StreamFlusher] send failed:', e); });
+            await this.sendChain;
             this.sentContent = true;
             this.lastFlush = Date.now();
             this.flushCount++;

package/dist/{utils → core/message}/stream-idle-monitor.js

@@ -34,7 +34,7 @@ export class StreamIdleMonitor {
             this.state.lastToolStartTime = Date.now();
             this.state.totalToolCalls++;
         }
-        if (type === 'text_delta' || type === 'result') {
+        if (type === 'text' || type === 'text_delta' || type === 'complete' || type === 'result') {
             this.state.hasReceivedText = true;
         }
         // 收到新事件，重置已触发级别