evolcore 0.0.1 → 0.0.3

package/dist/channels/qqbot.js

@@ -0,0 +1,409 @@
+import { logger } from '../utils/logger.js';
+import { markdownToPlainText } from '../utils/markdown-to-plain-text.js';
+import { requireOptional } from '../utils/npm-ops.js';
+import { middleOutputModePolicy, resolveShowActivities, showActivitiesPolicy } from '../core/channel-loader.js';
+import { formatItemsAsText } from '../core/message/items-formatter.js';
+import { initWelcomeManager, sendWelcomeIfNeeded } from '../utils/welcome.js';
+// ── QQBotChannel ────────────────────────────────────────────────────────────
+export class QQBotChannel {
+    agentAid;
+    channelName;
+    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;
+    // Welcome message manager
+    welcomeManager;
+    constructor(config, agentAid, channelName) {
+        this.agentAid = agentAid;
+        this.channelName = channelName;
+        this.config = config;
+        // 初始化 welcomeManager（使用共享帮助函数）
+        if (agentAid && channelName) {
+            this.welcomeManager = initWelcomeManager('qqbot', agentAid, channelName);
+        }
+    }
+    // ── 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 requireOptional('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;
+            // 首次交互欢迎消息（使用共享帮助函数）
+            await sendWelcomeIfNeeded(this.welcomeManager, event.senderId, chatId, (id, text) => this.sendMessage(id, text), 'QQBot');
+            // 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;
+        const fs = await import('fs');
+        const path = await import('path');
+        const os = await import('os');
+        const tmpPath = path.join(os.tmpdir(), `evolcore-qqbot-${Date.now()}.png`);
+        try {
+            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);
+            }
+        }
+        catch (error) {
+            logger.error(`[QQBot] sendImage failed for ${chatId}:`, error?.message || error);
+        }
+        finally {
+            try {
+                fs.unlinkSync(tmpPath);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    // ── 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';
+    async createInstance(inst, ctx) {
+        if (inst.enabled === false)
+            return null;
+        if (!isValidCredential(inst.appId) || !isValidCredential(inst.clientSecret))
+            return null;
+        const channel = new QQBotChannel({
+            appId: inst.appId,
+            clientSecret: inst.clientSecret,
+        }, ctx.agentName, inst.name);
+        const mode = resolveShowActivities(inst);
+        const adapter = {
+            channelName: inst.name,
+            channelKey: inst.name,
+            capabilities: { file: true, image: true, interaction: false, markdown: true, thought: false, status: false, thread: false, authenticatedApproval: true },
+            send: async (envelope, payload) => {
+                const channelId = envelope.channelId;
+                switch (payload.kind) {
+                    case 'result.text':
+                    case 'command.result':
+                    case 'command.error':
+                    case 'system.notice':
+                    case 'system.error':
+                    case 'result.error':
+                        await channel.sendMessage(channelId, payload.text);
+                        return;
+                    case 'result.file':
+                        await channel.sendFile(channelId, payload.filePath);
+                        return;
+                    case 'result.image':
+                        await channel.sendImage(channelId, payload.data);
+                        return;
+                    case 'activity.batch': {
+                        const filtered = payload.items.filter((i) => !(i.kind === 'tool_result' && i.ok));
+                        const text = formatItemsAsText(filtered);
+                        if (text)
+                            await channel.sendMessage(channelId, text);
+                        return;
+                    }
+                    case 'status.requires_action':
+                        await channel.sendMessage(channelId, '等待 owner 审批');
+                        return;
+                    case 'status.error':
+                        if (payload.metadata?.message)
+                            await channel.sendMessage(channelId, payload.metadata.message);
+                        return;
+                    case 'interaction':
+                        if (payload.fallbackText)
+                            await channel.sendMessage(channelId, payload.fallbackText);
+                        return;
+                    default: return;
+                }
+            },
+        };
+        const policy = {
+            canSwitchProject: (_, identity) => identity === 'owner' || identity === 'admin',
+            canListProjects: (_, identity) => identity === 'owner' || identity === 'admin',
+            canCreateSession: () => true,
+            canDeleteSession: () => true,
+            canImportCliSession: (_, identity) => identity === 'owner' || identity === 'admin',
+            messagePrefix: (chatType, peerName) => (chatType === 'group' && peerName) ? `[${peerName}] ` : '',
+            showMiddleResult: (chatType, identity) => showActivitiesPolicy(mode, chatType, identity),
+            middleOutputMode: (chatType, identity) => middleOutputModePolicy(mode, chatType, identity),
+            showIdleMonitor: (chatType, identity) => showActivitiesPolicy(mode, chatType, identity),
+            accumulateErrors: () => true,
+        };
+        return {
+            channelType: 'qqbot', adapter, channel,
+            policy,
+            options: { fileMarkerPattern: /\[SEND_FILE:(?:(\w+):)?([^\]]+)\]/g, supportsImages: true, flushDelay: inst.flushDelay },
+            connect: () => channel.connect(),
+            disconnect: () => channel.disconnect(),
+            onProjectPathRequest: () => Promise.resolve(ctx.defaultProjectPath),
+            registerBridge(bridge, channelType) {
+                bridge.register(adapter.channelName, (handler) => channel.onMessage(async (event) => {
+                    handler({
+                        channel: adapter.channelName, channelType, channelId: event.channelId,
+                        selfAID: ctx.agentName, content: event.content, images: event.images,
+                        chatType: event.chatType || 'private', peerId: event.peerId || '',
+                        peerName: event.peerName, messageId: event.messageId,
+                    });
+                }), (channelId, text) => channel.sendMessage(channelId, text), adapter, channelType);
+            },
+        };
+    }
+}