evolclaw 2.1.2 → 2.2.0

package/dist/core/message-queue.js

@@ -3,30 +3,56 @@ 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 + '-');
+        return key.startsWith(sessionKey + '::');
     }
     /**
      * 生成项目级别的队列 key
      */
     getQueueKey(sessionKey, projectPath) {
-        const projectName = path.basename(projectPath);
-        return `${sessionKey}-${projectName}`;
+        const normalized = projectPath ? path.resolve(projectPath) : '';
+        return `${sessionKey}::${normalized}`;
     }
-    async enqueue(sessionKey, message, projectPath) {
+    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) => {
@@ -34,11 +60,19 @@ export class MessageQueue {
                 this.queues.set(queueKey, []);
             }
             this.queues.get(queueKey).push({ message, projectPath, resolve, reject });
-            // 如果正在处理，触发中断
+            // 根据 interruptible 选项决定是否触发中断
             if (this.processing.has(queueKey)) {
-                logger.debug(`[Queue] ${queueKey} is processing, triggering interrupt`);
-                if (this.interruptCallback) {
-                    this.interruptCallback(sessionKey).catch(() => { });
+                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 {
@@ -51,6 +85,12 @@ export class MessageQueue {
         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`);
@@ -59,21 +99,76 @@ export class MessageQueue {
                 this.currentProjectPath = undefined;
                 return;
             }
-            const { message, projectPath, resolve, reject } = queue.shift();
+            // FIFO 贪心合并：弹出队首连续同 peerId 的消息
+            const items = this.dequeueGreedy(queue);
+            const merged = items.length === 1 ? items[0] : this.mergeItems(items);
             this.currentSessionKey = queueKey;
-            this.currentProjectPath = projectPath;
-            logger.debug(`[Queue] Processing message from ${message.channel}:${message.channelId}`);
+            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(message);
+                await this.handler(merged.message);
                 logger.debug(`[Queue] Message processed successfully`);
-                resolve();
+                resolves.forEach(r => r());
             }
             catch (error) {
                 logger.error(`[Queue] Message processing failed:`, error);
-                reject(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;
@@ -93,24 +188,53 @@ export class MessageQueue {
         }
         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 函数
      */
-    getProcessingProject(sessionKey) {
-        // 查找该 sessionKey 下正在处理的项目
-        for (const key of this.processing.keys()) {
-            if (this.matchesSession(key, 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;
-                }
-            }
+    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/permission.js

@@ -0,0 +1,58 @@
+import { summarizeToolInput } from '../utils/permission-utils.js';
+export class PermissionGateway {
+    pending = new Map();
+    timeout = 5 * 60 * 1000;
+    eventBus;
+    setEventBus(eventBus) {
+        this.eventBus = eventBus;
+    }
+    /**
+     * 请求人工审批。调用方负责模式判断（仅 approve 模式调用此方法）。
+     * 黑名单检查由调用方（preToolUseHook）在调用此方法前完成。
+     */
+    async requestPermission(sessionId, toolName, toolInput, sendPrompt, summary, reason) {
+        const requestId = `perm-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const displaySummary = summary || summarizeToolInput(toolName, toolInput);
+        const reasonLine = reason ? `\n原因：${reason}` : '';
+        this.eventBus?.publish({ type: 'permission:requested', sessionId, requestId, toolName, input: displaySummary });
+        await sendPrompt(`🔐 权限请求\n工具：${toolName}\n操作：${displaySummary}${reasonLine}\n\n回复 /perm allow 批准 或 /perm deny 拒绝`);
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                this.eventBus?.publish({ type: 'permission:timeout', sessionId, requestId });
+                resolve(false);
+            }, this.timeout);
+            this.pending.set(requestId, { sessionId, resolve, timer });
+        });
+    }
+    resolvePermission(sessionId, requestId, approved) {
+        const pending = this.pending.get(requestId);
+        if (!pending || pending.sessionId !== sessionId)
+            return false;
+        clearTimeout(pending.timer);
+        pending.resolve(approved);
+        this.pending.delete(requestId);
+        this.eventBus?.publish({ type: 'permission:resolved', sessionId, requestId, approved });
+        return true;
+    }
+    /** 中断时取消指定会话的所有 pending 权限请求 */
+    cancelAll(sessionId) {
+        for (const [requestId, pending] of this.pending.entries()) {
+            if (pending.sessionId === sessionId) {
+                clearTimeout(pending.timer);
+                pending.resolve(false);
+                this.pending.delete(requestId);
+            }
+        }
+    }
+    /** 获取指定会话的所有 pending requestId */
+    getPendingRequests(sessionId) {
+        const ids = [];
+        for (const [requestId, pending] of this.pending.entries()) {
+            if (pending.sessionId === sessionId) {
+                ids.push(requestId);
+            }
+        }
+        return ids;
+    }
+}

package/dist/core/session-file-adapter.js

@@ -0,0 +1,7 @@
+/**
+ * SessionFileAdapter — 会话文件操作的 Agent 抽象层
+ *
+ * 不同 Agent 后端（Claude / Codex）使用不同的会话文件存储格式和路径。
+ * 此接口将文件操作抽象为统一 API，由各 Agent 适配器分别实现。
+ */
+export {};