moltbot-wecom 1.0.2

package/README.md

@@ -0,0 +1,61 @@
+# Moltbot WeCom Channel
+
+WeCom (企业微信) 智能机器人的 Moltbot 插件。
+
+## 架构
+
+```
+企微用户 → 企微云 → wecom-proxy (解密/加密) ←WebSocket→ plugin (Moltbot)
+                  ↑                                         ↓
+                  ← 加密被动回复 ←─────────────────────── 回复消息
+```
+
+- **wecom-proxy**: 处理企微消息加解密，支持被动回复
+- **plugin**: 作为 Moltbot 的 channel 插件，处理消息逻辑
+
+## 安装
+
+```bash
+clawdbot plugins install moltbot-wecom-channel
+# 或
+npm link  # 本地开发
+```
+
+## 配置
+
+在 `moltbot.json`（或 `clawdbot.json`）的 `channels` 中添加：
+
+```json
+{
+  "channels": {
+    "wecom": {
+      "enabled": true,
+      "proxyUrl": "wss://your-wecom-proxy.com",
+      "proxyToken": "your-secret-token",
+      "pingInterval": 30000
+    }
+  }
+}
+```
+
+## 功能特性
+
+- ✅ 通过 WebSocket 连接 wecom-proxy，支持心跳保活
+- ✅ 消息去重（防止重复响应）
+- ✅ 被动回复机制（5秒内响应）
+- ✅ 自动重连
+
+## 被动回复流程
+
+1. wecom-proxy 接收企微加密消息并解密
+2. 通过 WebSocket 转发给 plugin（带 msgId）
+3. plugin 调用 Moltbot 处理消息
+4. plugin 将回复发回 wecom-proxy（带相同 msgId）
+5. wecom-proxy 加密回复并返回给企微
+6. 企微将回复投递给用户
+
+> **注意**: 企微要求 5 秒内响应。如果 AI 处理时间较长，可能需要实现主动回复 API。
+
+## 参考
+
+本实现参考了 [Feishu Moltbot Bridge](https://github.com/AlexAnys/feishu-moltbot-bridge) 的健壮性模式（去重、重连、心跳、群聊逻辑）。

package/moltbot.plugin.json

@@ -0,0 +1,27 @@
+{
+  "id": "wecom",
+  "name": "WeCom",
+  "description": "WeCom (企业微信) channel plugin — WebSocket proxy connection for Smart Bot",
+  "version": "1.0.1",
+  "channels": ["wecom"],
+  "configSchema": {
+    "type": "object",
+    "properties": {
+      "proxyUrl": {
+        "type": "string",
+        "description": "WeCom Proxy WebSocket URL (wss://your-domain.com)"
+      },
+      "proxyToken": {
+        "type": "string",
+        "description": "Authentication token for wecom-proxy connection"
+      },
+      "pingInterval": {
+        "type": "number",
+        "default": 30000,
+        "description": "WebSocket heartbeat interval in milliseconds"
+      }
+    },
+    "required": ["proxyUrl", "proxyToken"],
+    "additionalProperties": true
+  }
+}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "moltbot-wecom",
+  "version": "1.0.2",
+  "type": "module",
+  "description": "企业微信机器人插件 - 让 AI 助手接入企业微信智能机器人 | WeCom Smart Bot channel plugin for Moltbot",
+  "author": "xiajingan",
+  "license": "MIT",
+  "keywords": [
+    "moltbot",
+    "clawdbot",
+    "wecom",
+    "wechat",
+    "企业微信",
+    "企微机器人",
+    "chatbot",
+    "ai-agent",
+    "ai助手",
+    "messaging",
+    "channel-plugin",
+    "websocket",
+    "smart-bot"
+  ],
+  "main": "plugin.js",
+  "exports": {
+    ".": {
+      "import": "./plugin.js"
+    }
+  },
+  "files": [
+    "plugin.js",
+    "moltbot.plugin.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "moltbot": {
+    "extensions": [
+      "./plugin.js"
+    ],
+    "channel": {
+      "id": "wecom",
+      "label": "WeCom",
+      "selectionLabel": "WeCom (企业微信)",
+      "docsPath": "/channels/wecom",
+      "docsLabel": "wecom",
+      "blurb": "WeCom (Enterprise WeChat) Smart Bot with WebSocket proxy.",
+      "aliases": [
+        "企微",
+        "qw"
+      ],
+      "order": 80,
+      "quickstartAllowFrom": true
+    },
+    "install": {
+      "npmSpec": "moltbot-wecom",
+      "defaultChoice": "npm"
+    }
+  },
+  "dependencies": {
+    "ws": "^8.16.0"
+  },
+  "peerDependencies": {
+    "moltbot": ">=1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "moltbot": {
+      "optional": false
+    }
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/plugin.js

@@ -0,0 +1,243 @@
+const WebSocket = require('ws');
+
+/**
+ * Moltbot WeCom Channel Plugin
+ * 
+ * Config in moltbot.json:
+ * "channels": {
+ *   "wecom": {
+ *     "enabled": true,
+ *     "proxyUrl": "wss://...",
+ *     "proxyToken": "...",
+ *   }
+ * }
+ */
+
+module.exports = function(ctx) {
+    const log = ctx.logger ? ctx.logger('wecom') : console;
+    const cfg = ctx.config?.channels?.wecom || {};
+
+    if (!cfg.enabled) {
+        log.info('WeCom channel disabled');
+        return;
+    }
+
+    const PROXY_URL = cfg.proxyUrl || process.env.PROXY_URL;
+    const PROXY_TOKEN = cfg.proxyToken || process.env.PROXY_TOKEN;
+    const PING_INTERVAL_MS = cfg.pingInterval || 30000; // 30s heartbeat
+
+    if (!PROXY_URL) {
+        log.error('Missing proxyUrl for WeCom channel');
+        return;
+    }
+
+    // --- State & Dedup (Reference: feishu-moltbot-bridge) ---
+    const seen = new Map();
+    const SEEN_TTL = 10 * 60 * 1000;
+
+    function isDuplicate(id) {
+        if (!id) return false;
+        const now = Date.now();
+        for (const [k, ts] of seen) {
+            if (now - ts > SEEN_TTL) seen.delete(k);
+        }
+        if (seen.has(id)) return true;
+        seen.set(id, now);
+        return false;
+    }
+
+    // --- Group Logic (Reference: feishu-moltbot-bridge) ---
+    function shouldRespond(text, isGroup, mentions = []) {
+        if (!isGroup) return true; // Always respond to DM
+
+        // 1. Mentions (Smart Bot usually only receives @bot messages, but check anyway)
+        if (mentions.length > 0) return true;
+
+        // 2. Keywords/Questions
+        const t = text.toLowerCase();
+        if (/[？?]$/.test(text)) return true;
+        if (/\b(why|how|what|when|where|who|help)\b/.test(t)) return true;
+        
+        const triggers = ['help', 'bot', '小雀', '助手', 'moltbot'];
+        if (triggers.some(k => t.includes(k))) return true;
+
+        const verbs = ['帮', '请', '查', '分析', '总结', '翻译', '写', '改', '看看'];
+        if (verbs.some(k => t.includes(k))) return true;
+
+        return false;
+    }
+
+    // --- Connection ---
+    let ws;
+    let reconnectTimer;
+    let pingTimer;
+    let isAlive = false;
+
+    function connect() {
+        const url = `${PROXY_URL}?token=${PROXY_TOKEN || ''}`;
+        log.info(`Connecting to WeCom Proxy: ${PROXY_URL}`);
+        
+        ws = new WebSocket(url);
+
+        ws.on('open', () => {
+            log.info('WeCom Proxy connected');
+            isAlive = true;
+            if (reconnectTimer) {
+                clearTimeout(reconnectTimer);
+                reconnectTimer = null;
+            }
+            // Start heartbeat
+            startHeartbeat();
+        });
+
+        ws.on('message', async (data) => {
+            try {
+                const event = JSON.parse(data);
+                
+                // Handle pong response
+                if (event.kind === 'pong') {
+                    isAlive = true;
+                    return;
+                }
+                
+                if (event.kind !== 'message') return;
+
+                const msg = event.payload;
+                const msgId = event.msgId;
+                
+                // Basic validation
+                if (!msg || !msg.FromUserName || !msg.Content) {
+                    // Send empty reply for non-text messages
+                    sendReply(msgId, '');
+                    return;
+                }
+
+                const senderId = msg.FromUserName;
+                const text = msg.Content;
+
+                // Dedup
+                if (isDuplicate(msgId)) {
+                    log.debug(`Duplicate message ignored: ${msgId}`);
+                    sendReply(msgId, '');
+                    return;
+                }
+
+                // Group logic - Smart Bot usually only receives relevant messages
+                // but we keep the logic for safety
+                const isGroup = false; // Smart Bot messages are treated as direct
+                
+                if (isGroup && !shouldRespond(text, true)) {
+                    log.debug('Ignoring group message (no trigger)');
+                    sendReply(msgId, '');
+                    return;
+                }
+
+                log.info(`Rx [${senderId}]: ${text}`);
+
+                // Process message and get reply
+                try {
+                    const replyText = await processMessage(senderId, text, msgId);
+                    sendReply(msgId, replyText || '');
+                } catch (e) {
+                    log.error('Error processing message:', e);
+                    sendReply(msgId, '');
+                }
+
+            } catch (e) {
+                log.error('Error handling message', e);
+            }
+        });
+
+        ws.on('close', () => {
+            log.warn('WeCom Proxy disconnected');
+            isAlive = false;
+            stopHeartbeat();
+            scheduleReconnect();
+        });
+
+        ws.on('error', (e) => {
+            log.error('WeCom connection error:', e.message);
+            ws.terminate();
+        });
+    }
+
+    // --- Reply to Proxy ---
+    function sendReply(msgId, text) {
+        if (ws && ws.readyState === WebSocket.OPEN && msgId) {
+            ws.send(JSON.stringify({
+                kind: 'reply',
+                msgId: msgId,
+                text: text
+            }));
+        }
+    }
+
+    // --- Process message through Moltbot ---
+    async function processMessage(senderId, text, msgId) {
+        return new Promise((resolve, reject) => {
+            // Send to Moltbot Pipeline via ctx.receive
+            ctx.receive('wecom', {
+                from: senderId,
+                text: text,
+                msgId: msgId,
+                // The 'conn' object allows Moltbot to reply
+                conn: {
+                    send: async (replyText) => {
+                        if (!replyText || replyText === 'NO_REPLY') {
+                            resolve('');
+                            return;
+                        }
+                        log.info(`Tx [${senderId}]: ${replyText.slice(0, 50)}...`);
+                        resolve(replyText);
+                    }
+                }
+            }).catch(e => {
+                log.error('Pipeline error:', e);
+                resolve('');
+            });
+            
+            // Timeout fallback (Moltbot should respond quickly for passive reply)
+            setTimeout(() => resolve(''), 4000);
+        });
+    }
+
+    // --- Heartbeat ---
+    function startHeartbeat() {
+        stopHeartbeat();
+        pingTimer = setInterval(() => {
+            if (ws && ws.readyState === WebSocket.OPEN) {
+                if (!isAlive) {
+                    log.warn('Heartbeat timeout, reconnecting...');
+                    ws.terminate();
+                    return;
+                }
+                isAlive = false;
+                ws.send(JSON.stringify({ kind: 'ping', ts: Date.now() }));
+            }
+        }, PING_INTERVAL_MS);
+    }
+
+    function stopHeartbeat() {
+        if (pingTimer) {
+            clearInterval(pingTimer);
+            pingTimer = null;
+        }
+    }
+
+    function scheduleReconnect() {
+        if (reconnectTimer) return;
+        reconnectTimer = setTimeout(() => {
+            reconnectTimer = null;
+            connect();
+        }, 5000);
+    }
+
+    // --- Lifecycle ---
+    ctx.on('start', () => connect());
+    
+    ctx.on('stop', () => {
+        stopHeartbeat();
+        if (ws) ws.close();
+        if (reconnectTimer) clearTimeout(reconnectTimer);
+    });
+};