evolclaw 2.1.2 → 2.3.0

package/dist/channels/aun.js

@@ -1,28 +1,598 @@
-import { logger } from '../utils/logger.js';
+import { AUNClient } from '@eleans/aun-core-node';
+import fs from 'fs';
+import path from 'path';
+import { logger, localTimestamp } from '../utils/logger.js';
+import { normalizeChannelInstances } from '../config.js';
+import { resolvePaths } from '../paths.js';
 export class AUNChannel {
     config;
+    client = null;
     messageHandler;
     connected = false;
+    traceStream = null;
+    trace(dir, event, data) {
+        if (!this.traceStream)
+            return;
+        const line = JSON.stringify({ ts: localTimestamp(), dir, event, data });
+        this.traceStream.write(line + '\n');
+    }
+    getShortAid(aid) {
+        if (!aid)
+            return undefined;
+        const trimmed = aid.trim();
+        if (!trimmed)
+            return undefined;
+        return trimmed.split('.')[0] || trimmed;
+    }
+    extractTextPayload(payload) {
+        if (typeof payload === 'string')
+            return payload;
+        if (payload && typeof payload === 'object') {
+            const text = payload.text;
+            if (typeof text === 'string')
+                return text;
+            return JSON.stringify(payload);
+        }
+        return '';
+    }
+    hasExplicitMention(text, target) {
+        const escaped = target.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return new RegExp(`(^|\\s)@${escaped}(?=$|\\s|[.,!?;:，。！？；：]|[\\u4e00-\\u9fff])`).test(text);
+    }
+    stripTriggerMentions(text, selfAid) {
+        let result = text;
+        if (selfAid) {
+            const escapedAid = selfAid.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            result = result.replace(new RegExp(`(^|\\s)@${escapedAid}(?=$|\\s|[.,!?;:，。！？；：]|[\\u4e00-\\u9fff])`, 'g'), '$1');
+        }
+        result = result.replace(/(^|\s)@all(?=$|\s|[.,!?;:，。！？；：]|[\u4e00-\u9fff])/gi, '$1');
+        return result.replace(/[ \t]+/g, ' ').trim();
+    }
+    buildGroupReplyContext(taskId, senderAid, text) {
+        const replyContext = {};
+        if (taskId)
+            replyContext.threadId = taskId;
+        if (this.hasExplicitMention(text, 'all')) {
+            replyContext.mentionUserIds = ['all'];
+        }
+        else {
+            replyContext.mentionUserIds = [senderAid];
+        }
+        return replyContext;
+    }
+    acknowledgeImmediately(messageId, seq) {
+        if (seq != null && this.client) {
+            this.client.call('message.ack', { seq }).catch(e => {
+                logger.debug(`[AUN] Immediate ack failed: ${e}`);
+            });
+        }
+        if (messageId)
+            this.messageSeqMap.delete(messageId);
+    }
+    _aid;
+    seenMessages = new Map();
+    messageSeqMap = new Map(); // messageId → seq (for ack)
+    sentCount = new Map(); // channelId → 已发消息计数（用于判断最终回复）
+    // Reconnect state (TS-layer fallback, on top of SDK auto_reconnect)
+    intentionalDisconnect = false;
+    reconnectAttempt = 0;
+    reconnectTimer = null;
+    static RECONNECT_DELAYS = [60, 120, 300, 600]; // seconds
+    onChannelDown;
     constructor(config) {
         this.config = config;
+        if (config.aunTrace) {
+            const logPath = path.join(resolvePaths().logs, 'aun-trace.log');
+            this.traceStream = fs.createWriteStream(logPath, { flags: 'a' });
+            logger.info(`[AUN] Trace logging enabled: ${logPath}`);
+        }
     }
     async connect() {
-        // TODO: 集成真实的 AUN SDK
-        // 当前为占位符实现，确保接口一致性
-        this.connected = true;
-        logger.info(`[AUN] Connected as ${this.config.agentName}@${this.config.domain}`);
+        this.intentionalDisconnect = false;
+        this.reconnectAttempt = 0;
+        await this.initClient();
+    }
+    async initClient() {
+        // Clean up existing client if any
+        if (this.client) {
+            try {
+                await this.client.close();
+            }
+            catch { /* ignore */ }
+            this.client = null;
+        }
+        this.connected = false;
+        const aunPath = this.config.keystorePath || `${process.env.HOME || '~'}/.aun`;
+        const aidName = this.config.aid;
+        const encryptionSeed = this.config.encryptionSeed || process.env.AUN_ENCRYPTION_SEED || undefined;
+        // Gateway URL: 旧配置 gatewayUrl 优先，否则从 AID 推导
+        let gateway = this.config.gatewayUrl || '';
+        if (!gateway) {
+            const parts = aidName.split('.');
+            if (parts.length >= 3) {
+                const domain = parts.slice(1).join('.'); // alice.agentid.pub → agentid.pub
+                const port = this.config.gatewayPort || 443;
+                gateway = `wss://gateway.${domain}:${port}/aun`;
+            }
+        }
+        if (!gateway) {
+            logger.error('[AUN] Cannot derive gateway URL from AID');
+            return;
+        }
+        logger.info(`[AUN] Initializing: aid=${aidName}, gateway=${gateway}, aun_path=${aunPath}`);
+        // Create client with FileSecretStore (AES-256-GCM)
+        // 不传 encryption_seed 时，SDK 自动从 {aun_path}/.seed 文件派生密钥（与 aun_cli.py 对齐）
+        const rootCaPath = `${aunPath}/CA/root/root.crt`;
+        this.client = new AUNClient({
+            aun_path: aunPath,
+            root_ca_path: rootCaPath,
+            ...(encryptionSeed && { encryption_seed: encryptionSeed }),
+        });
+        // Set gateway URL (internal property, same as Python SDK)
+        this.client._gatewayUrl = gateway;
+        // Register event handlers before connecting
+        this.client.on('message.received', (data) => {
+            this.trace('IN', 'message.received', data);
+            const kind = (data && typeof data === 'object') ? data.kind ?? '' : '';
+            const keys = (data && typeof data === 'object') ? Object.keys(data).join(',') : typeof data;
+            logger.info(`[AUN][DIAG] message.received: kind=${kind} keys=${keys}`);
+            this.handleIncomingPrivateMessage(data);
+        });
+        this.client.on('group.message_created', (data) => {
+            this.trace('IN', 'group.message_created', data);
+            const gid = (data && typeof data === 'object') ? data.group_id ?? '' : '';
+            const sender = (data && typeof data === 'object') ? data.sender_aid ?? '' : '';
+            logger.info(`[AUN][DIAG] group.message_created: group_id=${gid} sender=${sender}`);
+            this.handleIncomingGroupMessage(data);
+        });
+        this.client.on('connection.state', (data) => {
+            this.trace('IN', 'connection.state', data);
+            this.handleConnectionState(data);
+        });
+        // Authenticate
+        let accessToken;
+        try {
+            logger.info(`[AUN] Authenticating as ${aidName}...`);
+            const auth = await this.client.auth.authenticate(aidName ? { aid: aidName } : undefined);
+            this.trace('IN', 'auth.result', { aid: auth.aid, gateway: auth.gateway, hasToken: !!auth.access_token });
+            accessToken = auth.access_token;
+            const resolvedGateway = auth.gateway || gateway;
+            this.client._gatewayUrl = resolvedGateway;
+            logger.info(`[AUN] Authenticated as ${auth.aid ?? '?'}, gateway=${resolvedGateway}`);
+        }
+        catch (e) {
+            const errMsg = e.message || String(e);
+            const errName = e.constructor?.name || 'Error';
+            logger.error(`[AUN] Authentication failed (${errName}): ${errMsg}`);
+            if (e.stack)
+                logger.debug(`[AUN] Auth stack: ${e.stack}`);
+            // Fallback: try direct token from env/config (legacy)
+            accessToken = this.config.accessToken || process.env.AUN_ACCESS_TOKEN || '';
+            if (!accessToken) {
+                logger.error(`[AUN] No accessToken fallback available, AUN channel disabled`);
+                return;
+            }
+            logger.warn(`[AUN] Using accessToken fallback`);
+        }
+        // Connect (SDK auto_reconnect handles transient failures)
+        try {
+            await this.client.connect({ access_token: accessToken, gateway: this.client._gatewayUrl }, { auto_reconnect: true, retry: { max_attempts: 5, initial_delay: 1.0, max_delay: 30.0 } });
+            this._aid = this.client.aid ?? undefined;
+            this.connected = true;
+            this.reconnectAttempt = 0;
+            logger.info(`[AUN] Connected as ${this._aid}`);
+        }
+        catch (e) {
+            logger.error(`[AUN] Connection failed: ${e}`);
+            return;
+        }
+    }
+    // ── Event handlers ──────────────────────────────────────────
+    async handleIncomingPrivateMessage(data) {
+        if (!data || typeof data !== 'object')
+            return;
+        const msg = data;
+        const fromAid = msg.from ?? '';
+        const payload = msg.payload ?? '';
+        const text = this.extractTextPayload(payload);
+        const taskId = msg.task_id;
+        const messageId = msg.message_id ?? '';
+        const seq = msg.seq;
+        // Detect @mentions
+        const mentions = [];
+        if (this._aid && text.includes(`@${this._aid}`)) {
+            mentions.push(this._aid);
+        }
+        this.dispatchMessage({
+            channelId: fromAid,
+            userId: fromAid,
+            text,
+            chatType: 'private',
+            messageId,
+            seq,
+            taskId,
+            mentions,
+        });
+    }
+    async handleIncomingGroupMessage(data) {
+        if (!data || typeof data !== 'object')
+            return;
+        const msg = data;
+        const groupId = msg.group_id ?? '';
+        const senderAid = msg.sender_aid ?? msg.from ?? '';
+        const payload = msg.payload ?? '';
+        const text = this.extractTextPayload(payload);
+        const taskId = msg.task_id;
+        const messageId = msg.message_id ?? '';
+        const seq = msg.seq;
+        logger.info(`[AUN][DIAG-GRP] full_msg=${JSON.stringify(msg).substring(0, 500)}`);
+        if (!groupId || !senderAid) {
+            this.acknowledgeImmediately(messageId, seq);
+            return;
+        }
+        if (this._aid && senderAid === this._aid) {
+            this.acknowledgeImmediately(messageId, seq);
+            return;
+        }
+        const mentionedSelf = this._aid ? this.hasExplicitMention(text, this._aid) : false;
+        const mentionedAll = this.hasExplicitMention(text, 'all');
+        if (!mentionedSelf && !mentionedAll) {
+            this.acknowledgeImmediately(messageId, seq);
+            return;
+        }
+        const strippedText = this.stripTriggerMentions(text, this._aid);
+        if (!strippedText) {
+            this.acknowledgeImmediately(messageId, seq);
+            return;
+        }
+        const mentions = mentionedAll ? ['all'] : (this._aid ? [this._aid] : []);
+        this.dispatchMessage({
+            channelId: groupId,
+            userId: senderAid,
+            peerName: this.getShortAid(senderAid),
+            text: strippedText,
+            chatType: 'group',
+            messageId,
+            seq,
+            taskId,
+            mentions,
+            replyContext: this.buildGroupReplyContext(taskId, senderAid, text),
+        });
+    }
+    dispatchMessage(event) {
+        // Dedup
+        if (event.messageId) {
+            if (this.seenMessages.has(event.messageId))
+                return;
+            this.seenMessages.set(event.messageId, Date.now());
+            setTimeout(() => this.seenMessages.delete(event.messageId), 5 * 60 * 1000);
+            // Track seq for acknowledge
+            if (event.seq != null) {
+                this.messageSeqMap.set(event.messageId, event.seq);
+            }
+        }
+        if (!this.messageHandler)
+            return;
+        const mentionObjects = event.mentions?.map(aid => ({ userId: aid }));
+        // Use caller-supplied replyContext (group path builds mentionUserIds);
+        // fall back to simple threadId-only context for private messages
+        let replyContext = event.replyContext;
+        if (!replyContext && event.taskId) {
+            replyContext = { threadId: event.taskId };
+        }
+        this.messageHandler({
+            channelId: event.channelId || '',
+            content: event.text || '',
+            chatType: event.chatType,
+            peerId: event.userId || event.channelId || '',
+            peerName: event.peerName,
+            messageId: event.messageId,
+            threadId: event.taskId,
+            mentions: mentionObjects,
+            replyContext,
+        }).catch(err => {
+            logger.error('[AUN] Message handler error:', err);
+        });
     }
+    handleConnectionState(data) {
+        if (!data || typeof data !== 'object')
+            return;
+        const state = data.state ?? '';
+        if (state === 'connected') {
+            this.connected = true;
+            this.reconnectAttempt = 0;
+            logger.info('[AUN] Connected');
+        }
+        else if (state === 'disconnected') {
+            this.connected = false;
+            logger.warn(`[AUN] Disconnected: ${data.error ?? 'unknown'}`);
+        }
+        else if (state === 'reconnecting') {
+            logger.info(`[AUN] SDK reconnecting (attempt ${data.attempt})`);
+        }
+        else if (state === 'terminal_failed') {
+            this.connected = false;
+            logger.error(`[AUN] Terminal failure: ${data.error ?? 'unknown'}`);
+            // SDK auto_reconnect exhausted; fall back to TS-layer reconnect
+            if (!this.intentionalDisconnect) {
+                this.scheduleReconnect();
+            }
+        }
+    }
+    // ── Public API (same interface as before) ───────────────────
     onMessage(handler) {
         this.messageHandler = handler;
     }
-    async sendMessage(sessionId, content) {
-        if (!this.connected)
-            throw new Error('AUN not connected');
-        // TODO: 实现真实的消息发送
-        logger.debug(`[AUN] Send to ${sessionId}: ${content.slice(0, 50)}...`);
+    async sendMessage(channelId, text, context) {
+        if (!this.connected || !this.client) {
+            logger.warn('[AUN] Cannot send: not connected');
+            return;
+        }
+        if (!text?.trim()) {
+            logger.warn('[AUN] Attempted to send empty message, skipping');
+            return;
+        }
+        let finalText = text;
+        // 多轮工具调用后的最终回复：仅在已有中间消息时添加前缀
+        if (context?.title && (this.sentCount.get(channelId) || 0) > 0) {
+            finalText = '最终回复\n' + text;
+        }
+        this.sentCount.set(channelId, (this.sentCount.get(channelId) || 0) + 1);
+        // Render outbound mentions for group sends
+        if (channelId.startsWith('grp_') && context?.mentionUserIds?.length) {
+            const mentionPrefix = context.mentionUserIds.includes('all')
+                ? '@all '
+                : context.mentionUserIds.map(id => `@${id}`).join(' ') + ' ';
+            finalText = mentionPrefix + finalText;
+        }
+        const params = { payload: { text: finalText }, encrypt: true };
+        if (context?.threadId)
+            params.task_id = context.threadId;
+        try {
+            if (channelId.startsWith('grp_')) {
+                params.group_id = channelId;
+                this.trace('OUT', 'group.send', params);
+                await this.client.call('group.send', params);
+            }
+            else {
+                params.to = channelId;
+                this.trace('OUT', 'message.send', params);
+                await this.client.call('message.send', params);
+            }
+        }
+        catch (e) {
+            this.trace('OUT', 'send.error', { channelId, error: String(e) });
+            logger.error(`[AUN] Send failed to ${channelId}: ${e}`);
+        }
+    }
+    acknowledge(messageId) {
+        const seq = this.messageSeqMap.get(messageId);
+        if (seq != null && this.client) {
+            this.client.call('message.ack', { seq }).catch(e => {
+                logger.debug(`[AUN] Ack failed: ${e}`);
+            });
+            this.messageSeqMap.delete(messageId);
+        }
+    }
+    sendProcessingStatus(channelId, status, sessionId, context) {
+        if (status === 'start')
+            this.sentCount.delete(channelId); // 新任务开始，重置计数
+        if (!this.client || !this.connected)
+            return;
+        const payload = {
+            type: 'processing',
+            status,
+            sessionId,
+            timestamp: Math.floor(Date.now() / 1000),
+        };
+        const params = {
+            payload,
+            encrypt: true, persist: false,
+        };
+        if (context?.threadId)
+            params.task_id = context.threadId;
+        if (channelId.startsWith('grp_')) {
+            params.group_id = channelId;
+            this.trace('OUT', 'group.send.status', params);
+            this.client.call('group.send', params).catch(e => {
+                logger.debug(`[AUN] Processing status failed: ${e}`);
+            });
+        }
+        else {
+            params.to = channelId;
+            this.trace('OUT', 'message.send.status', params);
+            this.client.call('message.send', params).catch(e => {
+                logger.debug(`[AUN] Processing status failed: ${e}`);
+            });
+        }
+    }
+    sendCustomPayload(channelId, payload) {
+        if (!this.client || !this.connected)
+            return;
+        // SDK 0.3.0 E2EE requires payload to be an object
+        let payloadObj;
+        try {
+            const parsed = JSON.parse(payload);
+            payloadObj = (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+                ? parsed : { text: payload };
+        }
+        catch {
+            payloadObj = { text: payload };
+        }
+        const sendParams = {
+            to: channelId, payload: payloadObj,
+            encrypt: true, persist: false,
+        };
+        this.trace('OUT', 'message.send.custom', sendParams);
+        this.client.call('message.send', sendParams).catch(e => {
+            logger.debug(`[AUN] Custom payload failed: ${e}`);
+        });
     }
     async disconnect() {
+        this.intentionalDisconnect = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.client) {
+            try {
+                await this.client.close();
+            }
+            catch { /* ignore */ }
+            this.client = null;
+        }
         this.connected = false;
+        if (this.traceStream) {
+            this.traceStream.end();
+            this.traceStream = null;
+        }
         logger.info('[AUN] Disconnected');
     }
+    // ── TS-layer reconnect (fallback when SDK auto_reconnect exhausted) ──
+    scheduleReconnect() {
+        if (this.intentionalDisconnect)
+            return;
+        if (this.reconnectTimer)
+            return;
+        const delays = AUNChannel.RECONNECT_DELAYS;
+        if (this.reconnectAttempt >= delays.length) {
+            logger.error(`[AUN] All ${delays.length} reconnect attempts exhausted, giving up`);
+            this.onChannelDown?.();
+            return;
+        }
+        const delay = delays[this.reconnectAttempt];
+        this.reconnectAttempt++;
+        logger.info(`[AUN] Scheduling reconnect #${this.reconnectAttempt}/${delays.length} in ${delay}s`);
+        this.reconnectTimer = setTimeout(async () => {
+            this.reconnectTimer = null;
+            try {
+                logger.info(`[AUN] Reconnect #${this.reconnectAttempt} starting...`);
+                await this.initClient();
+                logger.info(`[AUN] Reconnect #${this.reconnectAttempt} succeeded`);
+            }
+            catch (err) {
+                logger.error(`[AUN] Reconnect #${this.reconnectAttempt} failed:`, err);
+                this.scheduleReconnect();
+            }
+        }, delay * 1000);
+    }
+    /** Manually trigger reconnect (e.g. from /check reconnect command) */
+    async reconnect() {
+        if (this.connected)
+            return '已连接，无需重连';
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.reconnectAttempt = 0;
+        try {
+            await this.initClient();
+            return `重连成功 (${this._aid})`;
+        }
+        catch (err) {
+            this.scheduleReconnect();
+            return `重连失败: ${err}，已安排自动重试`;
+        }
+    }
+    /** Set callback for when all reconnect attempts are exhausted */
+    setOnChannelDown(callback) {
+        this.onChannelDown = callback;
+    }
+    /** Get current connection status */
+    getStatus() {
+        return {
+            connected: this.connected,
+            aid: this._aid,
+            reconnectAttempt: this.reconnectAttempt,
+            maxAttempts: AUNChannel.RECONNECT_DELAYS.length,
+        };
+    }
+}
+// Plugin implementation
+export class AUNChannelPlugin {
+    name = 'aun';
+    isEnabled(config) {
+        const raw = config.channels?.aun;
+        if (!raw)
+            return false;
+        if (Array.isArray(raw)) {
+            return raw.some(inst => inst.enabled !== false && !!inst.aid);
+        }
+        return raw.enabled !== false && !!raw.aid;
+    }
+    async createChannels(config) {
+        const instances = normalizeChannelInstances(config.channels?.aun, 'aun');
+        const result = [];
+        for (const inst of instances) {
+            if (inst.enabled === false || !inst.aid)
+                continue;
+            const channel = new AUNChannel({
+                aid: inst.aid,
+                keystorePath: inst.keystorePath,
+                gatewayPort: inst.gatewayPort,
+                gatewayUrl: inst.gatewayUrl,
+                accessToken: inst.accessToken,
+                flushDelay: inst.flushDelay,
+                encryptionSeed: inst.encryptionSeed,
+                aunTrace: config.debug?.aunTrace,
+            });
+            const adapter = {
+                channelName: inst.name,
+                sendText: (id, text, context) => channel.sendMessage(id, text, context),
+                acknowledge: (messageId) => { channel.acknowledge(messageId); return Promise.resolve(); },
+                sendProcessingStatus: (id, status, sessionId, context) => channel.sendProcessingStatus(id, status, sessionId, context),
+                sendCustomPayload: (id, payload) => channel.sendCustomPayload(id, payload),
+            };
+            const policy = {
+                canSwitchProject: (chatType, identity) => identity === 'owner',
+                canListProjects: (chatType, identity) => identity === 'owner',
+                canCreateSession: (chatType, identity) => true,
+                canDeleteSession: (chatType, identity) => true,
+                canImportCliSession: (chatType, identity) => identity === 'owner',
+                messagePrefix: () => '',
+                showMiddleResult: (chatType, identity) => {
+                    const mode = inst.showActivities ?? config.showActivities ?? 'all';
+                    if (mode === 'none')
+                        return false;
+                    if (mode === 'dm-only')
+                        return chatType === 'private';
+                    if (mode === 'owner-dm-only')
+                        return chatType === 'private' && identity === 'owner';
+                    return true;
+                },
+                showIdleMonitor: (chatType, identity) => {
+                    const mode = inst.showActivities ?? config.showActivities ?? 'all';
+                    if (mode === 'none')
+                        return false;
+                    if (mode === 'dm-only')
+                        return chatType === 'private';
+                    if (mode === 'owner-dm-only')
+                        return chatType === 'private' && identity === 'owner';
+                    return true;
+                },
+                accumulateErrors: (chatType, identity) => true,
+            };
+            const options = {
+                flushDelay: inst.flushDelay ?? 3,
+                fileMarkerPattern: /\[SEND_FILE:(?:(\w+):)?([^\]]+)\]/g,
+            };
+            result.push({
+                channelType: 'aun',
+                adapter,
+                channel,
+                policy,
+                options,
+                connect: () => channel.connect(),
+                disconnect: () => channel.disconnect(),
+            });
+        }
+        return result;
+    }
+    async createChannel(config) {
+        const instances = await this.createChannels(config);
+        if (instances.length === 0) {
+            throw new Error('AUN config missing (aid required, e.g. "mybot.agentid.pub")');
+        }
+        return instances[0];
+    }
 }