evolclaw 2.1.2 → 2.2.0

package/dist/channels/aun.js

@@ -1,28 +1,435 @@
+import { AUNClient } from '@aun/core-node';
 import { logger } from '../utils/logger.js';
 export class AUNChannel {
     config;
+    client = null;
     messageHandler;
     connected = false;
+    _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;
     }
     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 对齐）
+        this.client = new AUNClient({
+            aun_path: aunPath,
+            ...(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.handleIncomingPrivateMessage(data));
+        this.client.on('group.message_created', (data) => this.handleIncomingGroupMessage(data));
+        this.client.on('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);
+            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 = typeof payload === 'string' ? payload : (payload ? JSON.stringify(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 = typeof payload === 'string' ? payload : (payload ? JSON.stringify(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: groupId,
+            userId: senderAid,
+            text,
+            chatType: 'group',
+            messageId,
+            seq,
+            taskId,
+            mentions,
+        });
+    }
+    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 }));
+        let replyContext;
+        if (event.taskId) {
+            replyContext = { threadId: event.taskId };
+        }
+        this.messageHandler({
+            channelId: event.channelId || '',
+            content: event.text || '',
+            chatType: event.chatType,
+            peerId: event.userId || event.channelId || '',
+            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);
+        const params = { payload: finalText, encrypt: true };
+        if (context?.threadId)
+            params.task_id = context.threadId;
+        try {
+            if (channelId.startsWith('grp_')) {
+                params.group_id = channelId;
+                await this.client.call('group.send', params);
+            }
+            else {
+                params.to = channelId;
+                await this.client.call('message.send', params);
+            }
+        }
+        catch (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 = JSON.stringify({
+            type: 'processing',
+            status,
+            sessionId,
+            timestamp: Math.floor(Date.now() / 1000),
+        });
+        const params = {
+            to: channelId, payload,
+            encrypt: true, persist: false,
+        };
+        if (context?.threadId)
+            params.task_id = context.threadId;
+        this.client.call('message.send', params).catch(e => {
+            logger.debug(`[AUN] Processing status failed: ${e}`);
+        });
+    }
+    sendCustomPayload(channelId, payload) {
+        if (!this.client || !this.connected)
+            return;
+        this.client.call('message.send', {
+            to: channelId, payload,
+            encrypt: true, persist: false,
+        }).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;
         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) {
+        return config.channels?.aun?.enabled !== false && !!config.channels?.aun?.aid;
+    }
+    async createChannel(config) {
+        const aunConfig = config.channels?.aun;
+        if (!aunConfig?.aid) {
+            throw new Error('AUN config missing (aid required, e.g. "mybot.agentid.pub")');
+        }
+        const channel = new AUNChannel({
+            aid: aunConfig.aid,
+            keystorePath: aunConfig.keystorePath,
+            gatewayPort: aunConfig.gatewayPort,
+            gatewayUrl: aunConfig.gatewayUrl,
+            accessToken: aunConfig.accessToken,
+            flushDelay: aunConfig.flushDelay,
+            encryptionSeed: aunConfig.encryptionSeed,
+        });
+        const adapter = {
+            name: 'aun',
+            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: (chatType, peerName) => (chatType === 'group' && peerName) ? `[${peerName}] ` : '',
+            showMiddleResult: (chatType, identity) => {
+                const mode = aunConfig.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 = aunConfig.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: aunConfig.flushDelay ?? 3,
+            fileMarkerPattern: /\[SEND_FILE:(?:(\w+):)?([^\]]+)\]/g,
+        };
+        return {
+            adapter,
+            channel,
+            policy,
+            options,
+            connect: () => channel.connect(),
+            disconnect: () => channel.disconnect(),
+        };
+    }
 }