evolclaw 2.3.0 → 2.5.0

package/dist/channels/wecom.js

@@ -0,0 +1,549 @@
+import crypto from 'node:crypto';
+import { logger } from '../utils/logger.js';
+import { normalizeChannelInstances, getChannelShowActivities } from '../config.js';
+// ── WecomChannel ───────────────────────────────────────────────────────────────
+export class WecomChannel {
+    config;
+    client = null;
+    connected = false;
+    messageHandler = null;
+    seenMessages = new Map();
+    cleanupInterval = null;
+    projectPathProvider = null;
+    // Stream reply state: reqId → { streamId, frame }
+    activeStreams = new Map();
+    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(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 import('@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;
+        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';
+    isEnabled(config) {
+        const raw = config.channels?.wecom;
+        if (!raw)
+            return false;
+        if (Array.isArray(raw)) {
+            return raw.some(inst => inst.enabled !== false && isValidCredential(inst.botId) && isValidCredential(inst.secret));
+        }
+        if (raw.enabled === false)
+            return false;
+        return isValidCredential(raw.botId) && isValidCredential(raw.secret);
+    }
+    async createChannels(config) {
+        const instances = normalizeChannelInstances(config.channels?.wecom, 'wecom');
+        const result = [];
+        for (const inst of instances) {
+            if (inst.enabled === false)
+                continue;
+            if (!isValidCredential(inst.botId) || !isValidCredential(inst.secret))
+                continue;
+            const channel = new WecomChannel({
+                botId: inst.botId,
+                secret: inst.secret,
+            });
+            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: 'wecom',
+                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('WeCom config missing or invalid');
+        }
+        return instances[0];
+    }
+}