evolcore 0.0.1 → 0.0.2

package/dist/channels/wecom.js

@@ -0,0 +1,565 @@
+import crypto from 'node:crypto';
+import { logger } from '../utils/logger.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';
+// ── WecomChannel ───────────────────────────────────────────────────────────────
+export class WecomChannel {
+    agentAid;
+    channelName;
+    config;
+    client = null;
+    connected = false;
+    messageHandler = null;
+    seenMessages = new Map();
+    cleanupInterval = null;
+    projectPathProvider = null;
+    // Stream reply state: reqId → { streamId, frame }
+    activeStreams = new Map();
+    // Welcome message manager
+    welcomeManager;
+    constructor(config, agentAid, channelName) {
+        this.agentAid = agentAid;
+        this.channelName = channelName;
+        this.config = config;
+        // 初始化 welcomeManager（使用共享帮助函数）
+        if (agentAid && channelName) {
+            this.welcomeManager = initWelcomeManager('wecom', agentAid, channelName);
+        }
+    }
+    // ── Public helpers (testable) ─────────────────────────────────────────────
+    isDuplicate(msgId) {
+        if (this.seenMessages.has(msgId))
+            return true;
+        this.seenMessages.set(msgId, Date.now());
+        return false;
+    }
+    resolveChatId(chattype, chatid, userid) {
+        return chattype === 'group' && chatid ? chatid : userid;
+    }
+    // ── Lifecycle ─────────────────────────────────────────────────────────────
+    async connect() {
+        const { botId, secret } = this.config;
+        if (!botId || !secret) {
+            throw new Error('WeCom botId/secret not configured');
+        }
+        const { WSClient } = await requireOptional('@wecom/aibot-node-sdk');
+        this.client = new WSClient({ botId, secret });
+        // Message events
+        this.client.on('message', (frame) => {
+            this.handleIncoming(frame).catch((err) => {
+                logger.error('[WeCom] Failed to process incoming message:', err);
+            });
+        });
+        // Event callbacks (enter_chat, etc.)
+        this.client.on('event.enter_chat', (frame) => {
+            const body = frame?.body;
+            if (body) {
+                logger.debug(`[WeCom] User entered chat: userid=${body.from?.userid} chattype=${body.chattype}`);
+            }
+        });
+        // Lifecycle events
+        this.client.on('authenticated', () => {
+            logger.info('[WeCom] WebSocket authenticated');
+        });
+        this.client.on('disconnected', (reason) => {
+            logger.warn(`[WeCom] WebSocket disconnected: ${reason}`);
+            this.connected = false;
+        });
+        this.client.on('reconnecting', (attempt) => {
+            logger.info(`[WeCom] Reconnecting (attempt ${attempt})...`);
+        });
+        this.client.on('error', (error) => {
+            logger.error('[WeCom] WebSocket error:', error);
+        });
+        this.client.connect();
+        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('[WeCom] Channel connected');
+    }
+    async disconnect() {
+        this.connected = false;
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        if (this.client) {
+            try {
+                this.client.disconnect();
+            }
+            catch { /* ignore */ }
+            this.client = null;
+        }
+        logger.info('[WeCom] Channel disconnected');
+    }
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    getStatus() {
+        return { connected: this.connected };
+    }
+    async reconnect() {
+        await this.disconnect();
+        try {
+            await this.connect();
+            return '重连成功';
+        }
+        catch (err) {
+            return `重连失败: ${err instanceof Error ? err.message : String(err)}`;
+        }
+    }
+    // ── Inbound message handling ──────────────────────────────────────────────
+    async handleIncoming(frame) {
+        const body = frame?.body;
+        if (!body)
+            return;
+        const msgId = body.msgid;
+        const chattype = body.chattype || 'single';
+        const chatid = body.chatid;
+        const userid = body.from?.userid || '';
+        const msgtype = body.msgtype;
+        // Dedup
+        if (msgId && this.isDuplicate(msgId)) {
+            logger.debug(`[WeCom] Duplicate message skipped: ${msgId}`);
+            return;
+        }
+        const channelId = this.resolveChatId(chattype, chatid, userid);
+        const chatTypeNorm = chattype === 'group' ? 'group' : 'private';
+        // Store frame for stream replies
+        this.activeStreams.set(channelId, {
+            streamId: crypto.randomUUID(),
+            frame: { headers: frame.headers },
+        });
+        if (!this.messageHandler)
+            return;
+        // 首次交互欢迎消息（使用共享帮助函数）
+        await sendWelcomeIfNeeded(this.welcomeManager, userid, channelId, (id, text) => this.sendMessage(id, text), 'WeCom');
+        if (msgtype === 'text') {
+            const text = body.text?.content?.trim();
+            if (!text)
+                return;
+            // Handle quote/reference
+            let content = text;
+            if (body.quote) {
+                const quoteText = body.quote.text?.content || '';
+                if (quoteText) {
+                    content = `[引用: ${quoteText}]\n${text}`;
+                }
+            }
+            await this.messageHandler({
+                channelId, content, chatType: chatTypeNorm,
+                peerId: userid, messageId: msgId,
+            });
+        }
+        else if (msgtype === 'image') {
+            await this.handleImageMessage(body, channelId, chatTypeNorm, userid, msgId, frame);
+        }
+        else if (msgtype === 'voice') {
+            const voiceText = body.voice?.content?.trim();
+            if (voiceText) {
+                await this.messageHandler({
+                    channelId, content: voiceText, chatType: chatTypeNorm,
+                    peerId: userid, messageId: msgId,
+                });
+            }
+        }
+        else if (msgtype === 'file') {
+            await this.handleFileMessage(body, channelId, chatTypeNorm, userid, msgId, frame);
+        }
+        else if (msgtype === 'video') {
+            await this.handleVideoMessage(body, channelId, chatTypeNorm, userid, msgId, frame);
+        }
+        else if (msgtype === 'mixed') {
+            await this.handleMixedMessage(body, channelId, chatTypeNorm, userid, msgId, frame);
+        }
+        else {
+            await this.messageHandler({
+                channelId,
+                content: `[不支持的消息类型: ${msgtype}]`,
+                chatType: chatTypeNorm, peerId: userid, messageId: msgId,
+            });
+        }
+    }
+    // ── Inbound media handling ────────────────────────────────────────────────
+    async handleImageMessage(body, channelId, chatType, peerId, msgId, frame) {
+        const imageUrl = body.image?.url;
+        const aeskey = body.image?.aeskey;
+        if (!imageUrl) {
+            logger.warn('[WeCom] Image message without url');
+            await this.messageHandler({
+                channelId, content: '[图片下载失败：缺少下载链接]',
+                chatType, peerId, messageId: msgId,
+            });
+            return;
+        }
+        try {
+            let buffer;
+            if (this.client && aeskey) {
+                const result = await this.client.downloadFile(imageUrl, aeskey);
+                buffer = result.buffer;
+            }
+            else {
+                const { safeFetch } = await import('../utils/media-cache.js');
+                buffer = await safeFetch(imageUrl, { skipSsrfCheck: true });
+            }
+            const { validateImage } = await import('../utils/media-cache.js');
+            const result = await validateImage(buffer);
+            if (result.mime) {
+                await this.messageHandler({
+                    channelId,
+                    content: '用户发送了一张图片，请分析这张图片的内容。',
+                    chatType, peerId, messageId: msgId,
+                    images: [{ data: buffer.toString('base64'), mimeType: result.mime }],
+                });
+            }
+            else {
+                logger.warn(`[WeCom] Image validation failed`);
+                await this.messageHandler({
+                    channelId, content: '[图片验证失败]',
+                    chatType, peerId, messageId: msgId,
+                });
+            }
+        }
+        catch (error) {
+            logger.error('[WeCom] Failed to download image:', error);
+            await this.messageHandler({
+                channelId, content: '[图片下载失败]',
+                chatType, peerId, messageId: msgId,
+            });
+        }
+    }
+    async handleFileMessage(body, channelId, chatType, peerId, msgId, frame) {
+        const fileUrl = body.file?.url;
+        const aeskey = body.file?.aeskey;
+        const fileName = body.file?.filename || 'unknown';
+        if (!fileUrl) {
+            logger.warn('[WeCom] File message without url');
+            await this.messageHandler({
+                channelId, content: `[文件下载失败：缺少下载链接] ${fileName}`,
+                chatType, peerId, messageId: msgId,
+            });
+            return;
+        }
+        try {
+            let buffer;
+            if (this.client && aeskey) {
+                const result = await this.client.downloadFile(fileUrl, aeskey);
+                buffer = result.buffer;
+            }
+            else {
+                const { safeFetch } = await import('../utils/media-cache.js');
+                buffer = await safeFetch(fileUrl, { skipSsrfCheck: true });
+            }
+            const { saveToUploads, sanitizeFileName } = await import('../utils/media-cache.js');
+            const projectPath = this.projectPathProvider
+                ? await this.projectPathProvider(channelId)
+                : process.cwd();
+            const { filePath } = saveToUploads(buffer, sanitizeFileName(fileName), projectPath);
+            await this.messageHandler({
+                channelId,
+                content: `用户发送了文件：${fileName}\n文件已保存到：${filePath}\n请使用 Read 工具读取并分析文件内容。`,
+                chatType, peerId, messageId: msgId,
+            });
+        }
+        catch (error) {
+            logger.error('[WeCom] Failed to download file:', error);
+            await this.messageHandler({
+                channelId, content: `[文件下载失败] ${fileName}`,
+                chatType, peerId, messageId: msgId,
+            });
+        }
+    }
+    async handleVideoMessage(body, channelId, chatType, peerId, msgId, frame) {
+        const videoUrl = body.video?.url;
+        const aeskey = body.video?.aeskey;
+        if (!videoUrl) {
+            await this.messageHandler({
+                channelId, content: '[视频下载失败：缺少下载链接]',
+                chatType, peerId, messageId: msgId,
+            });
+            return;
+        }
+        try {
+            let buffer;
+            if (this.client && aeskey) {
+                const result = await this.client.downloadFile(videoUrl, aeskey);
+                buffer = result.buffer;
+            }
+            else {
+                const { safeFetch } = await import('../utils/media-cache.js');
+                buffer = await safeFetch(videoUrl, { skipSsrfCheck: true });
+            }
+            const { saveToUploads } = await import('../utils/media-cache.js');
+            const projectPath = this.projectPathProvider
+                ? await this.projectPathProvider(channelId)
+                : process.cwd();
+            const fileName = `video_${Date.now()}.mp4`;
+            const { filePath } = saveToUploads(buffer, fileName, projectPath);
+            await this.messageHandler({
+                channelId,
+                content: `用户发送了视频：${fileName}\n文件已保存到：${filePath}`,
+                chatType, peerId, messageId: msgId,
+            });
+        }
+        catch (error) {
+            logger.error('[WeCom] Failed to download video:', error);
+            await this.messageHandler({
+                channelId, content: '[视频下载失败]',
+                chatType, peerId, messageId: msgId,
+            });
+        }
+    }
+    async handleMixedMessage(body, channelId, chatType, peerId, msgId, frame) {
+        const msgItems = body.mixed?.msg_item;
+        if (!Array.isArray(msgItems)) {
+            await this.messageHandler({
+                channelId, content: '[不支持的图文混排格式]',
+                chatType, peerId, messageId: msgId,
+            });
+            return;
+        }
+        let text = '';
+        const images = [];
+        for (const item of msgItems) {
+            if (item.msgtype === 'text' && item.text?.content) {
+                text += item.text.content;
+            }
+            else if (item.msgtype === 'image' && item.image?.url) {
+                try {
+                    let buffer;
+                    if (this.client && item.image.aeskey) {
+                        const result = await this.client.downloadFile(item.image.url, item.image.aeskey);
+                        buffer = result.buffer;
+                    }
+                    else {
+                        const { safeFetch } = await import('../utils/media-cache.js');
+                        buffer = await safeFetch(item.image.url, { skipSsrfCheck: true });
+                    }
+                    const { validateImage } = await import('../utils/media-cache.js');
+                    const result = await validateImage(buffer);
+                    if (result.mime) {
+                        images.push({ data: buffer.toString('base64'), mimeType: result.mime });
+                    }
+                }
+                catch (error) {
+                    logger.warn('[WeCom] Failed to download mixed image:', error);
+                }
+            }
+        }
+        const prompt = text.trim() || (images.length > 0 ? '用户发送了一张图片，请分析这张图片的内容。' : '[空消息]');
+        await this.messageHandler({
+            channelId, content: prompt, chatType,
+            peerId, messageId: msgId,
+            images: images.length > 0 ? images : undefined,
+        });
+    }
+    // ── Outbound: text ────────────────────────────────────────────────────────
+    async sendMessage(chatId, content) {
+        if (!content || content.trim() === '') {
+            logger.warn('[WeCom] Attempted to send empty message, skipping');
+            return;
+        }
+        if (!this.client) {
+            logger.error('[WeCom] Client not connected, cannot send message');
+            return;
+        }
+        try {
+            // Try stream reply first (responds to a specific user message)
+            const stream = this.activeStreams.get(chatId);
+            if (stream) {
+                await this.client.replyStream(stream.frame, stream.streamId, content, true);
+                this.activeStreams.delete(chatId);
+                logger.debug(`[WeCom] Sent stream reply to ${chatId}`);
+                return;
+            }
+            // Fallback: proactive send (markdown)
+            await this.client.sendMessage(chatId, {
+                msgtype: 'markdown',
+                markdown: { content },
+            });
+            logger.debug(`[WeCom] Sent proactive message to ${chatId}`);
+        }
+        catch (error) {
+            logger.error(`[WeCom] sendMessage failed for ${chatId}:`, error.message);
+        }
+    }
+    // ── Outbound: image ───────────────────────────────────────────────────────
+    async sendImage(chatId, png) {
+        if (!this.client) {
+            logger.warn('[WeCom] Client not connected for sendImage');
+            return;
+        }
+        try {
+            const result = await this.client.uploadMedia(png, {
+                type: 'image',
+                filename: 'image.png',
+            });
+            const mediaId = result?.media_id;
+            if (!mediaId) {
+                logger.error('[WeCom] Media upload failed: no media_id');
+                return;
+            }
+            // Try reply media if we have an active frame, else proactive send
+            const stream = this.activeStreams.get(chatId);
+            if (stream) {
+                await this.client.replyMedia(stream.frame, 'image', mediaId);
+                this.activeStreams.delete(chatId);
+            }
+            else {
+                await this.client.sendMediaMessage(chatId, 'image', mediaId);
+            }
+            logger.debug(`[WeCom] Sent image to ${chatId}`);
+        }
+        catch (error) {
+            logger.error(`[WeCom] sendImage failed for ${chatId}:`, error.message);
+        }
+    }
+    // ── Outbound: file ────────────────────────────────────────────────────────
+    async sendFile(chatId, filePath) {
+        if (!this.client) {
+            logger.warn('[WeCom] Client not connected for sendFile');
+            return;
+        }
+        try {
+            const fs = await import('fs');
+            const path = await import('path');
+            if (!fs.existsSync(filePath)) {
+                logger.error(`[WeCom] File not found: ${filePath}`);
+                return;
+            }
+            // Detect image files → route to sendImage
+            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 buf = fs.readFileSync(filePath);
+            const fileName = path.basename(filePath);
+            const result = await this.client.uploadMedia(buf, {
+                type: 'file',
+                filename: fileName,
+            });
+            const mediaId = result?.media_id;
+            if (!mediaId) {
+                logger.error('[WeCom] File upload failed: no media_id');
+                return;
+            }
+            const stream = this.activeStreams.get(chatId);
+            if (stream) {
+                await this.client.replyMedia(stream.frame, 'file', mediaId);
+                this.activeStreams.delete(chatId);
+            }
+            else {
+                await this.client.sendMediaMessage(chatId, 'file', mediaId);
+            }
+            logger.debug(`[WeCom] Sent file ${fileName} to ${chatId}`);
+        }
+        catch (error) {
+            logger.error(`[WeCom] sendFile failed for ${chatId}:`, error.message);
+        }
+    }
+}
+// ── Plugin ─────────────────────────────────────────────────────────────────────
+function isValidCredential(value) {
+    return !!value && !value.includes('your-') && !value.includes('placeholder');
+}
+export class WecomChannelPlugin {
+    name = 'wecom';
+    async createInstance(inst, ctx) {
+        if (inst.enabled === false)
+            return null;
+        if (!isValidCredential(inst.botId) || !isValidCredential(inst.secret))
+            return null;
+        const channel = new WecomChannel({
+            botId: inst.botId,
+            secret: inst.secret,
+        }, 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: 'wecom', 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);
+            },
+        };
+    }
+}