evolclaw 2.1.1 → 2.2.0

package/dist/core/event-bus.js

@@ -0,0 +1,32 @@
+import { EventEmitter } from 'events';
+export class EventBus extends EventEmitter {
+    publish(event) {
+        const handlers = [
+            ...this.listeners(event.type),
+            ...this.listeners('*'),
+        ];
+        for (const handler of handlers) {
+            try {
+                handler(event);
+            }
+            catch (err) {
+                console.error(`[EventBus] Handler error for ${event.type}:`, err);
+            }
+        }
+    }
+    subscribe(eventType, handler) {
+        this.on(eventType, handler);
+    }
+    subscribeAll(handler) {
+        this.on('*', handler);
+    }
+    subscribePrefix(prefix, handler) {
+        this.on('*', (event) => {
+            if (event.type.startsWith(prefix))
+                handler(event);
+        });
+    }
+    unsubscribe(eventType, handler) {
+        this.off(eventType, handler);
+    }
+}

package/dist/core/ipc-server.js

@@ -0,0 +1,71 @@
+import net from 'net';
+import fs from 'fs';
+import { logger } from '../utils/logger.js';
+export class IpcServer {
+    socketPath;
+    getStatus;
+    server = null;
+    constructor(socketPath, getStatus) {
+        this.socketPath = socketPath;
+        this.getStatus = getStatus;
+    }
+    start() {
+        // Remove stale socket file
+        try {
+            fs.unlinkSync(this.socketPath);
+        }
+        catch { }
+        this.server = net.createServer((conn) => {
+            let buf = '';
+            conn.on('data', (data) => {
+                buf += data.toString();
+                // Simple newline-delimited JSON protocol
+                const idx = buf.indexOf('\n');
+                if (idx === -1)
+                    return;
+                const line = buf.slice(0, idx);
+                buf = buf.slice(idx + 1);
+                try {
+                    const cmd = JSON.parse(line);
+                    const response = this.handleCommand(cmd);
+                    conn.end(JSON.stringify(response) + '\n');
+                }
+                catch {
+                    conn.end(JSON.stringify({ error: 'invalid request' }) + '\n');
+                }
+            });
+            conn.on('error', () => { }); // ignore client errors
+        });
+        this.server.on('error', (err) => {
+            logger.error('[IPC] Server error:', err);
+        });
+        this.server.listen(this.socketPath, () => {
+            // Ensure socket is readable by current user only
+            try {
+                fs.chmodSync(this.socketPath, 0o600);
+            }
+            catch { }
+            logger.info(`[IPC] Listening on ${this.socketPath}`);
+        });
+    }
+    stop() {
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+        try {
+            fs.unlinkSync(this.socketPath);
+        }
+        catch { }
+    }
+    handleCommand(cmd) {
+        switch (cmd.type) {
+            case 'status':
+                return this.getStatus();
+            case 'ping':
+                return { pong: true, pid: process.pid };
+            default:
+                return { error: `unknown command: ${cmd.type}` };
+        }
+    }
+}

package/dist/core/message-bridge.js

@@ -0,0 +1,187 @@
+import { logger } from '../utils/logger.js';
+import { StreamDebouncer } from '../utils/stream-debouncer.js';
+/**
+ * MessageBridge — Channel 与 Core 之间的消息桥梁
+ *
+ * 入站管线：Channel.onMessage → owner 绑定 → 命令路由 → session 解析
+ *          → 策略前缀 → 构造 Message → debounce → ACK → enqueue
+ * 出站：命令响应通过 sendReply 回调直接发送到渠道
+ */
+export class MessageBridge {
+    config;
+    sessionManager;
+    processor;
+    messageQueue;
+    cmdHandler;
+    eventBus;
+    debouncers = new Map();
+    defaultDebounce;
+    constructor(config, sessionManager, processor, messageQueue, cmdHandler, eventBus) {
+        this.config = config;
+        this.sessionManager = sessionManager;
+        this.processor = processor;
+        this.messageQueue = messageQueue;
+        this.cmdHandler = cmdHandler;
+        this.eventBus = eventBus;
+        this.defaultDebounce = config.debounce ?? 2;
+    }
+    getDebouncer(channelName) {
+        let d = this.debouncers.get(channelName);
+        if (!d) {
+            const chConfig = this.config.channels?.[channelName];
+            const seconds = chConfig?.debounce ?? this.defaultDebounce;
+            d = new StreamDebouncer(seconds);
+            this.debouncers.set(channelName, d);
+        }
+        return d;
+    }
+    /**
+     * 为渠道注册消息桥梁：入站处理管线 + 出站命令响应
+     *
+     * @param channelName     渠道标识
+     * @param onMessage       注册入站消息监听
+     * @param sendReply       出站：命令响应发送回调
+     * @param adapter         渠道适配器（用于 ACK）
+     */
+    register(channelName, onMessage, sendReply, adapter) {
+        onMessage(async (msg) => {
+            let content = msg.content.trim();
+            // 0. 自定义消息快速路径（menu.query 等）
+            if (await this.handleCustomPayload(content, channelName, msg, sendReply, adapter))
+                return;
+            // 1. owner 绑定
+            if (msg.peerId)
+                await this.autoBindOwner(channelName, msg.peerId);
+            // 2. 命令快速路径（去除引用前缀后检查，兼容话题中引用上文的情况）
+            const contentForCmd = content.replace(/^(>[^\n]*\n)+\n?/, '').trim();
+            if (await this.handleCommand(contentForCmd || content, channelName, msg.channelId, (text) => sendReply(msg.channelId, text, msg.replyContext), msg.peerId, msg.threadId))
+                return;
+            // 3. session 解析（使用 Channel 层填充的 chatType）
+            const chatType = msg.chatType || 'private';
+            const metadata = {};
+            if (msg.replyContext)
+                metadata.replyContext = msg.replyContext;
+            if (chatType === 'private' && msg.peerId) {
+                metadata.peerId = msg.peerId;
+                if (msg.peerName)
+                    metadata.peerName = msg.peerName;
+            }
+            const session = await this.sessionManager.getOrCreateSession(channelName, msg.channelId, this.config.projects?.defaultPath || process.cwd(), msg.threadId, Object.keys(metadata).length ? metadata : undefined, undefined, msg.peerId, chatType);
+            // 4. 消息前缀（由 policy 决定）
+            const channelInfo = this.processor.getChannelInfo?.(channelName);
+            if (channelInfo?.policy) {
+                const prefix = channelInfo.policy.messagePrefix(chatType, msg.peerName);
+                if (prefix)
+                    content = prefix + content;
+            }
+            // 5. 构造完整消息
+            const fullMessage = {
+                channel: channelName, channelId: msg.channelId, content,
+                chatType,
+                images: msg.images, timestamp: Date.now(),
+                peerId: msg.peerId, peerName: msg.peerName,
+                messageId: msg.messageId,
+                mentions: msg.mentions, threadId: msg.threadId,
+                replyContext: msg.replyContext,
+            };
+            // 6. ACK + debounce/enqueue
+            //    ACK 在到达时立即做（每条独立 ACK），不等合并
+            //    Interrupt 模式（单聊）→ 入队前 debounce 合并
+            //    FIFO 模式（群聊）    → 跳过 debouncer，独立入队，出队时贪心合并
+            if (fullMessage.messageId)
+                adapter?.acknowledge?.(fullMessage.messageId).catch(() => { });
+            const isInterrupt = chatType !== 'group';
+            const doEnqueue = async (m) => {
+                return this.messageQueue.enqueue(session.id, m, session.projectPath, {
+                    interruptible: isInterrupt,
+                });
+            };
+            if (isInterrupt) {
+                const debouncer = this.getDebouncer(channelName);
+                if (debouncer.enabled) {
+                    const debounceKey = msg.peerId ? `${session.id}:${msg.peerId}` : session.id;
+                    await debouncer.submit(debounceKey, fullMessage, doEnqueue);
+                }
+                else {
+                    await doEnqueue(fullMessage);
+                }
+            }
+            else {
+                // 群聊 FIFO：直接入队，由 MessageQueue.processNext 出队时合并
+                await doEnqueue(fullMessage);
+            }
+        });
+    }
+    /** 自定义消息快速路径：拦截 menu.query 等自定义 payload，返回 true 表示已处理 */
+    async handleCustomPayload(content, channel, msg, sendReply, adapter) {
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch {
+            return false;
+        }
+        if (!parsed || typeof parsed !== 'object' || !parsed.type)
+            return false;
+        if (parsed.type === 'menu.query') {
+            const identity = this.sessionManager.resolveIdentity(channel, msg.peerId);
+            const isAdmin = identity.role === 'owner';
+            const items = this.cmdHandler.getMenuItems(isAdmin);
+            const response = JSON.stringify({ type: 'menu.response', items });
+            if (adapter?.sendCustomPayload) {
+                adapter.sendCustomPayload(msg.channelId, response);
+            }
+            else {
+                await sendReply(msg.channelId, response);
+            }
+            return true;
+        }
+        return false;
+    }
+    /** 首次交互自动绑定 owner */
+    async autoBindOwner(channel, userId) {
+        const channelConfig = this.config.channels?.[channel];
+        if (channelConfig && !channelConfig.owner) {
+            const { setOwner } = await import('../config.js');
+            setOwner(this.config, channel, userId);
+            logger.info(`[Owner] Auto-bound ${channel} owner: ${userId}`);
+            this.eventBus.publish({ type: 'channel:owner-bound', channel, userId });
+        }
+    }
+    /** 命令快速路径：返回 true 表示已处理 */
+    async handleCommand(content, channel, channelId, sendReply, userId, threadId) {
+        if (!this.cmdHandler.isCommand(content))
+            return false;
+        const cmdResult = await this.cmdHandler.handle(content, channel, channelId, (_cid, text, opts) => sendReply(text), userId, threadId);
+        if (cmdResult === null)
+            return false;
+        if (cmdResult) {
+            try {
+                await sendReply(cmdResult);
+            }
+            catch (error) {
+                logger.error(`[${channel}] Failed to send command response:`, error);
+            }
+        }
+        return true;
+    }
+    /**
+     * 撤回消息：先查 debounce 窗口，再查 message queue。
+     * @returns true 如果找到并取消
+     */
+    cancel(messageId) {
+        // 阶段 1: debounce 窗口（尚未入队）
+        for (const d of this.debouncers.values()) {
+            if (d.cancel(messageId))
+                return true;
+        }
+        // 阶段 2: 已入队但未处理（合并后 messageId 可能是逗号分隔的多个 id）
+        return this.messageQueue.cancel(messageId);
+    }
+    /** 清理资源 */
+    dispose() {
+        for (const d of this.debouncers.values())
+            d.dispose();
+        this.debouncers.clear();
+    }
+}