evolclaw 2.4.0 → 2.5.0

package/dist/channels/qqbot.js

@@ -0,0 +1,391 @@
+import { logger } from '../utils/logger.js';
+import { markdownToPlainText } from '../utils/format.js';
+import { normalizeChannelInstances, getChannelShowActivities } from '../config.js';
+// ── QQBotChannel ────────────────────────────────────────────────────────────
+export class QQBotChannel {
+    config;
+    client = null;
+    connected = false;
+    messageHandler = null;
+    recallHandler;
+    seenMessages = new Map();
+    chatTypeCache = new Map();
+    msgIdCache = new Map();
+    groupOpenidCache = new Map();
+    markdownFailed = false;
+    cleanupInterval = null;
+    projectPathProvider = null;
+    constructor(config) {
+        this.config = config;
+    }
+    // ── Public helpers (testable) ──────────────────────────────────────────────
+    isDuplicate(msgId) {
+        if (this.seenMessages.has(msgId))
+            return true;
+        this.seenMessages.set(msgId, Date.now());
+        return false;
+    }
+    resolveChatId(event) {
+        return event.type === 'group' && event.groupOpenid ? event.groupOpenid : event.senderId;
+    }
+    shouldProcess(type) {
+        return type === 'c2c' || type === 'group';
+    }
+    // ── Lifecycle ──────────────────────────────────────────────────────────────
+    async connect() {
+        const { appId, clientSecret } = this.config;
+        if (!appId || !clientSecret || appId.includes('your-') || clientSecret.includes('your-')) {
+            throw new Error('QQBot appId/clientSecret not configured');
+        }
+        const { QQBotClient } = await import('pure-qqbot');
+        this.client = new QQBotClient({
+            appId,
+            clientSecret,
+            typingKeepAlive: true,
+            logger: {
+                info: (msg) => logger.debug(`[QQBot/SDK] ${msg}`),
+                error: (msg) => logger.error(`[QQBot/SDK] ${msg}`),
+                debug: (msg) => logger.debug(`[QQBot/SDK] ${msg}`),
+            },
+        });
+        this.client.onMessage(async (event) => {
+            await this.handleIncoming(event);
+        });
+        await this.client.start();
+        this.client.startBackgroundRefresh();
+        this.connected = true;
+        // Hourly cleanup of old dedup entries
+        this.cleanupInterval = setInterval(() => {
+            const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+            for (const [id, ts] of this.seenMessages) {
+                if (ts < cutoff)
+                    this.seenMessages.delete(id);
+            }
+        }, 60 * 60 * 1000);
+        logger.info('[QQBot] Connected via WebSocket Gateway v2');
+    }
+    async disconnect() {
+        this.connected = false;
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        if (this.client) {
+            try {
+                this.client.stopBackgroundRefresh();
+                this.client.stop();
+            }
+            catch { /* ignore */ }
+            this.client = null;
+        }
+        logger.info('[QQBot] Disconnected');
+    }
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    onRecall(handler) {
+        this.recallHandler = handler;
+    }
+    // ── Inbound message handling ───────────────────────────────────────────────
+    async handleIncoming(event) {
+        try {
+            // Filter: only c2c and group
+            if (!this.shouldProcess(event.type))
+                return;
+            // Dedup
+            if (event.messageId && this.isDuplicate(event.messageId)) {
+                logger.debug(`[QQBot] Duplicate message skipped: ${event.messageId}`);
+                return;
+            }
+            const chatId = this.resolveChatId(event);
+            const chatType = event.type === 'group' ? 'group' : 'private';
+            // Cache for outbound routing
+            this.chatTypeCache.set(chatId, chatType);
+            this.msgIdCache.set(chatId, event.messageId);
+            if (event.groupOpenid)
+                this.groupOpenidCache.set(chatId, event.groupOpenid);
+            if (!this.messageHandler)
+                return;
+            // Check for attachments (images/files)
+            const attachments = event.attachments || [];
+            const imageAttachments = attachments.filter(a => a.content_type?.startsWith('image/'));
+            const fileAttachments = attachments.filter(a => !a.content_type?.startsWith('image/'));
+            if (imageAttachments.length > 0) {
+                await this.handleImageAttachments(imageAttachments, event, chatId, chatType);
+            }
+            else if (fileAttachments.length > 0) {
+                await this.handleFileAttachments(fileAttachments, event, chatId, chatType);
+            }
+            else {
+                // Pure text
+                const text = (event.content || '').trim();
+                if (!text)
+                    return;
+                await this.messageHandler({
+                    channelId: chatId, content: text, chatType,
+                    peerId: event.senderId || '', peerName: event.senderName,
+                    messageId: event.messageId,
+                });
+            }
+        }
+        catch (error) {
+            logger.error('[QQBot] Failed to process incoming message:', error);
+        }
+    }
+    // ── Inbound media handling ─────────────────────────────────────────────────
+    async handleImageAttachments(attachments, event, chatId, chatType) {
+        const images = [];
+        for (const att of attachments) {
+            if (!att.url)
+                continue;
+            try {
+                const { safeFetch, validateImage } = await import('../utils/media-cache.js');
+                const buffer = await safeFetch(att.url, { skipSsrfCheck: true });
+                const result = await validateImage(buffer);
+                if (result.mime) {
+                    images.push({ data: buffer.toString('base64'), mimeType: result.mime });
+                }
+                else {
+                    logger.warn(`[QQBot] Image validation failed: ${'reason' in result ? result.reason : 'unknown'}`);
+                }
+            }
+            catch (error) {
+                logger.error('[QQBot] Failed to download image:', error);
+            }
+        }
+        const text = (event.content || '').trim();
+        const prompt = text || (images.length > 0 ? '用户发送了一张图片，请分析这张图片的内容。' : '[空消息]');
+        await this.messageHandler({
+            channelId: chatId, content: prompt, chatType,
+            peerId: event.senderId || '', peerName: event.senderName,
+            messageId: event.messageId,
+            images: images.length > 0 ? images : undefined,
+        });
+    }
+    async handleFileAttachments(attachments, event, chatId, chatType) {
+        for (const att of attachments) {
+            if (!att.url)
+                continue;
+            const fileName = att.filename || 'unknown';
+            try {
+                const { safeFetch, saveToUploads, sanitizeFileName } = await import('../utils/media-cache.js');
+                const projectPath = this.projectPathProvider
+                    ? await this.projectPathProvider(chatId)
+                    : process.cwd();
+                const buffer = await safeFetch(att.url, { skipSsrfCheck: true });
+                const { filePath } = saveToUploads(buffer, sanitizeFileName(fileName), projectPath);
+                await this.messageHandler({
+                    channelId: chatId,
+                    content: `用户发送了文件：${fileName}\n文件已保存到：${filePath}\n请使用 Read 工具读取并分析文件内容。`,
+                    chatType, peerId: event.senderId || '', peerName: event.senderName,
+                    messageId: event.messageId,
+                });
+            }
+            catch (error) {
+                logger.error('[QQBot] Failed to download file:', error);
+                await this.messageHandler({
+                    channelId: chatId, content: `[文件下载失败] ${fileName}`,
+                    chatType, peerId: event.senderId || '', peerName: event.senderName,
+                    messageId: event.messageId,
+                });
+            }
+        }
+    }
+    // ── Outbound: text (markdown with fallback) ────────────────────────────────
+    async sendMessage(chatId, content) {
+        if (!this.client)
+            return;
+        const chatType = this.chatTypeCache.get(chatId);
+        const msgId = this.msgIdCache.get(chatId);
+        // Try Markdown first, fallback to plain text
+        if (!this.markdownFailed) {
+            try {
+                if (chatType === 'group') {
+                    const groupOpenid = this.groupOpenidCache.get(chatId) || chatId;
+                    await this.client.sendGroupMessage(groupOpenid, content, msgId);
+                }
+                else {
+                    await this.client.sendPrivateMarkdown(chatId, content, msgId);
+                }
+                return; // success
+            }
+            catch (error) {
+                const errMsg = String(error?.message || error);
+                // Check if this is a markdown permission error
+                if (errMsg.includes('not support') || errMsg.includes('permission') ||
+                    errMsg.includes('markdown') || error?.code === 304003 || error?.code === 304004) {
+                    logger.warn('[QQBot] Markdown not supported, falling back to plain text globally');
+                    this.markdownFailed = true;
+                    // Fall through to plain text below
+                }
+                else {
+                    // Other error — log and return, don't fallback
+                    logger.error(`[QQBot] sendMessage failed for ${chatId}:`, errMsg);
+                    return;
+                }
+            }
+        }
+        // Plain text fallback
+        try {
+            const plainText = markdownToPlainText(content);
+            if (chatType === 'group') {
+                const groupOpenid = this.groupOpenidCache.get(chatId) || chatId;
+                await this.client.sendGroupMessage(groupOpenid, plainText, msgId);
+            }
+            else {
+                await this.client.sendPrivateMessage(chatId, plainText, msgId);
+            }
+        }
+        catch (error) {
+            logger.error(`[QQBot] sendMessage (plaintext) failed for ${chatId}:`, error?.message || error);
+        }
+    }
+    // ── Outbound: image ────────────────────────────────────────────────────────
+    async sendImage(chatId, png) {
+        if (!this.client)
+            return;
+        try {
+            const fs = await import('fs');
+            const path = await import('path');
+            const os = await import('os');
+            const tmpPath = path.join(os.tmpdir(), `evolclaw-qqbot-${Date.now()}.png`);
+            fs.writeFileSync(tmpPath, png);
+            const chatType = this.chatTypeCache.get(chatId);
+            const msgId = this.msgIdCache.get(chatId);
+            if (chatType === 'group') {
+                const groupOpenid = this.groupOpenidCache.get(chatId) || chatId;
+                await this.client.sendGroupImage(groupOpenid, `file://${tmpPath}`, msgId);
+            }
+            else {
+                await this.client.sendPrivateImage(chatId, `file://${tmpPath}`, msgId);
+            }
+            try {
+                fs.unlinkSync(tmpPath);
+            }
+            catch { /* ignore */ }
+        }
+        catch (error) {
+            logger.error(`[QQBot] sendImage failed for ${chatId}:`, error?.message || error);
+        }
+    }
+    // ── Outbound: file ─────────────────────────────────────────────────────────
+    async sendFile(chatId, filePath) {
+        if (!this.client)
+            return;
+        try {
+            const fs = await import('fs');
+            const header = Buffer.alloc(12);
+            const fd = fs.openSync(filePath, 'r');
+            fs.readSync(fd, header, 0, 12, 0);
+            fs.closeSync(fd);
+            const { fileTypeFromBuffer } = await import('file-type');
+            const ftype = await fileTypeFromBuffer(header);
+            if (ftype && ftype.mime.startsWith('image/')) {
+                const buf = fs.readFileSync(filePath);
+                return this.sendImage(chatId, buf);
+            }
+            const chatType = this.chatTypeCache.get(chatId);
+            const msgId = this.msgIdCache.get(chatId);
+            if (chatType === 'group') {
+                const groupOpenid = this.groupOpenidCache.get(chatId) || chatId;
+                await this.client.sendGroupFile(groupOpenid, `file://${filePath}`, msgId);
+            }
+            else {
+                await this.client.sendPrivateFile(chatId, `file://${filePath}`, msgId);
+            }
+        }
+        catch (error) {
+            logger.error(`[QQBot] sendFile failed for ${chatId}:`, error?.message || error);
+        }
+    }
+}
+// ── Plugin ─────────────────────────────────────────────────────────────────────
+function isValidCredential(value) {
+    return !!value && !value.includes('your-') && !value.includes('placeholder');
+}
+export class QQBotChannelPlugin {
+    name = 'qqbot';
+    isEnabled(config) {
+        const raw = config.channels?.qqbot;
+        if (!raw)
+            return false;
+        if (Array.isArray(raw)) {
+            return raw.some(inst => inst.enabled !== false && isValidCredential(inst.appId) && isValidCredential(inst.clientSecret));
+        }
+        if (raw.enabled === false)
+            return false;
+        return isValidCredential(raw.appId) && isValidCredential(raw.clientSecret);
+    }
+    async createChannels(config) {
+        const instances = normalizeChannelInstances(config.channels?.qqbot, 'qqbot');
+        const result = [];
+        for (const inst of instances) {
+            if (inst.enabled === false)
+                continue;
+            if (!isValidCredential(inst.appId) || !isValidCredential(inst.clientSecret))
+                continue;
+            const channel = new QQBotChannel({
+                appId: inst.appId,
+                clientSecret: inst.clientSecret,
+            });
+            const adapter = {
+                channelName: inst.name,
+                sendText: (id, text) => channel.sendMessage(id, text),
+                sendFile: (id, filePath) => channel.sendFile(id, filePath),
+                sendImage: (id, png) => channel.sendImage(id, png),
+            };
+            const policy = {
+                canSwitchProject: (_chatType, identity) => identity === 'owner' || identity === 'admin',
+                canListProjects: (_chatType, identity) => identity === 'owner' || identity === 'admin',
+                canCreateSession: () => true,
+                canDeleteSession: () => true,
+                canImportCliSession: (_chatType, identity) => identity === 'owner' || identity === 'admin',
+                messagePrefix: (chatType, peerName) => (chatType === 'group' && peerName) ? `[${peerName}] ` : '',
+                showMiddleResult: (chatType, identity) => {
+                    const mode = getChannelShowActivities(config, inst.name);
+                    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 = getChannelShowActivities(config, inst.name);
+                    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: () => true,
+            };
+            const options = {
+                fileMarkerPattern: /\[SEND_FILE:(?:(\w+):)?([^\]]+)\]/g,
+                supportsImages: true,
+                flushDelay: inst.flushDelay,
+            };
+            result.push({
+                channelType: 'qqbot',
+                adapter,
+                channel,
+                policy,
+                options,
+                connect: () => channel.connect(),
+                disconnect: () => channel.disconnect(),
+                onProjectPathRequest: () => Promise.resolve(config.projects?.defaultPath || process.cwd()),
+            });
+        }
+        return result;
+    }
+    async createChannel(config) {
+        const instances = await this.createChannels(config);
+        if (instances.length === 0) {
+            throw new Error('QQBot config missing or invalid');
+        }
+        return instances[0];
+    }
+}

package/dist/channels/wechat.js

@@ -4,7 +4,11 @@ import path from 'path';
 import { resolvePaths } from '../paths.js';
 import { logger } from '../utils/logger.js';
 import { sanitizeFileName, saveToUploads, safeFetch } from '../utils/media-cache.js';
+import { markdownToPlainText } from '../utils/format.js';
 const CHANNEL_VERSION = '1.0.0';
+const ILINK_APP_ID = 'bot';
+// iLink-App-ClientVersion: major<<16 | minor<<8 | patch (uint32)
+const ILINK_APP_CLIENT_VERSION = String((1 << 16) | (0 << 8) | 0); // 1.0.0 = 65536
 const DEFAULT_LONG_POLL_TIMEOUT_MS = 35_000;
 const DEFAULT_API_TIMEOUT_MS = 15_000;
 const DEFAULT_CONFIG_TIMEOUT_MS = 10_000;
@@ -67,38 +71,6 @@ async function downloadMedia(cdnMedia, hexKey) {
         return encrypted; // 无 key = 明文
     return decryptAesEcb(encrypted, parseAesKey(aesKeyBase64));
 }
-// ── Markdown → Plain Text ───────────────────────────────────────────────────
-function markdownToPlainText(text) {
-    let result = text;
-    // Code blocks: strip fences, keep content
-    result = result.replace(/```[^\n]*\n?([\s\S]*?)```/g, (_, code) => code.trim());
-    // Images: remove entirely
-    result = result.replace(/!\[[^\]]*\]\([^)]*\)/g, '');
-    // Links: keep display text only
-    result = result.replace(/\[([^\]]+)\]\([^)]*\)/g, '$1');
-    // Tables: remove separator rows
-    result = result.replace(/^\|[\s:|-]+\|$/gm, '');
-    result = result.replace(/^\|(.+)\|$/gm, (_, inner) => inner.split('|').map(cell => cell.trim()).join('  '));
-    // Bold/italic
-    result = result.replace(/\*\*(.+?)\*\*/g, '$1');
-    result = result.replace(/\*(.+?)\*/g, '$1');
-    result = result.replace(/__(.+?)__/g, '$1');
-    result = result.replace(/_(.+?)_/g, '$1');
-    // Strikethrough
-    result = result.replace(/~~(.+?)~~/g, '$1');
-    // Inline code
-    result = result.replace(/`([^`]+)`/g, '$1');
-    // Headers
-    result = result.replace(/^#{1,6}\s+/gm, '');
-    // Blockquotes
-    result = result.replace(/^>\s?/gm, '');
-    // Horizontal rules
-    result = result.replace(/^[-*_]{3,}$/gm, '');
-    // List markers
-    result = result.replace(/^(\s*)[-*+]\s/gm, '$1');
-    result = result.replace(/^(\s*)\d+\.\s/gm, '$1');
-    return result.trim();
-}
 // ── Message Text Extraction ─────────────────────────────────────────────────
 function extractTextFromMessage(msg) {
     if (!msg.item_list?.length)
@@ -129,6 +101,7 @@ function extractTextFromMessage(msg) {
 export class WechatChannel {
     config;
     messageHandler;
+    recallHandler;
     abortController;
     connected = false;
     // 内部状态（不外泄到核心层）
@@ -153,6 +126,9 @@ export class WechatChannel {
     onMessage(handler) {
         this.messageHandler = handler;
     }
+    onRecall(handler) {
+        this.recallHandler = handler;
+    }
     /** 注册 session 过期通知回调（用于跨渠道通知用户） */
     onSessionExpiredNotify(handler) {
         this.onSessionExpired = handler;
@@ -179,6 +155,13 @@ export class WechatChannel {
         catch {
             // ignore
         }
+        // 通知 ilink 后端：bot 上线
+        try {
+            await this.notifyLifecycle('notifystart');
+        }
+        catch (err) {
+            logger.warn('[WeChat] notifyStart failed during startup (ignored):', err);
+        }
         this.abortController = new AbortController();
         // 启动长轮询（不 await，后台运行）
         this.pollLoop(this.abortController.signal).catch(err => {
@@ -196,6 +179,13 @@ export class WechatChannel {
             this.abortController.abort();
             this.abortController = undefined;
         }
+        // 通知 ilink 后端：bot 下线
+        try {
+            await this.notifyLifecycle('notifystop');
+        }
+        catch (err) {
+            logger.warn('[WeChat] notifyStop failed during shutdown (ignored):', err);
+        }
         logger.info('[WeChat] Channel disconnected');
     }
     /** Get current connection status */
@@ -638,6 +628,12 @@ export class WechatChannel {
         logger.info(`[WeChat] Sent media to ${to}, type=${item.type}`);
     }
     // ── ilink API Helpers ─────────────────────────────────────────────────
+    /** Notify ilink backend of bot lifecycle events (start/stop). */
+    async notifyLifecycle(action) {
+        const body = JSON.stringify({ base_info: { channel_version: CHANNEL_VERSION } });
+        await this.apiFetch(`ilink/bot/msg/${action}`, body, DEFAULT_CONFIG_TIMEOUT_MS);
+        logger.info(`[WeChat] ${action} succeeded`);
+    }
     async apiFetch(endpoint, body, timeoutMs, externalSignal) {
         const base = this.config.baseUrl.endsWith('/') ? this.config.baseUrl : `${this.config.baseUrl}/`;
         const url = new URL(endpoint, base).toString();
@@ -676,6 +672,8 @@ export class WechatChannel {
             'AuthorizationType': 'ilink_bot_token',
             'Content-Length': String(Buffer.byteLength(body, 'utf-8')),
             'X-WECHAT-UIN': wechatUin,
+            'iLink-App-Id': ILINK_APP_ID,
+            'iLink-App-ClientVersion': ILINK_APP_CLIENT_VERSION,
         };
         if (this.config.token?.trim()) {
             headers['Authorization'] = `Bearer ${this.config.token.trim()}`;
@@ -707,7 +705,7 @@ export class WechatChannel {
         });
     }
 }
-import { normalizeChannelInstances } from '../config.js';
+import { normalizeChannelInstances, getChannelShowActivities } from '../config.js';
 export class WechatChannelPlugin {
     name = 'wechat';
     isEnabled(config) {
@@ -735,14 +733,14 @@ export class WechatChannelPlugin {
                 sendFile: (id, filePath) => channel.sendFile(id, filePath),
             };
             const policy = {
-                canSwitchProject: (chatType, identity) => identity === 'owner',
-                canListProjects: (chatType, identity) => identity === 'owner',
+                canSwitchProject: (chatType, identity) => identity === 'owner' || identity === 'admin',
+                canListProjects: (chatType, identity) => identity === 'owner' || identity === 'admin',
                 canCreateSession: (chatType, identity) => true,
                 canDeleteSession: (chatType, identity) => true,
-                canImportCliSession: (chatType, identity) => identity === 'owner',
+                canImportCliSession: (chatType, identity) => identity === 'owner' || identity === 'admin',
                 messagePrefix: (chatType, peerName) => '',
                 showMiddleResult: (chatType, identity) => {
-                    const mode = inst.showActivities ?? config.showActivities ?? 'all';
+                    const mode = getChannelShowActivities(config, inst.name);
                     if (mode === 'none')
                         return false;
                     if (mode === 'dm-only')
@@ -752,7 +750,7 @@ export class WechatChannelPlugin {
                     return true;
                 },
                 showIdleMonitor: (chatType, identity) => {
-                    const mode = inst.showActivities ?? config.showActivities ?? 'all';
+                    const mode = getChannelShowActivities(config, inst.name);
                     if (mode === 'none')
                         return false;
                     if (mode === 'dm-only')