myagent-ai 1.0.0

package/chatbot/wechat_bot.py

@@ -0,0 +1,558 @@
+"""
+chatbot/wechat_bot.py - 微信机器人
+=====================================
+微信机器人适配器。
+
+注意: 微信没有官方的个人号第三方机器人 API。
+本实现支持以下模式:
+  1. WxPusher (微信公众号消息推送 + 接收用户消息回调)
+  2. HTTP 桥接模式 (通过 wechaty / comwechat 等桥接)
+  3. 企业微信 Webhook (单向推送)
+
+推荐方案:
+  - 需要双向通信: HTTP 桥接模式
+  - 只需推送: WxPusher / 企业微信 Webhook
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import hashlib
+import time
+from typing import Optional, Dict, Any
+
+from chatbot.base import BaseChatBot, ChatMessage, ChatResponse
+
+try:
+    import aiohttp
+    HAS_AIOHTTP = True
+except ImportError:
+    HAS_AIOHTTP = False
+
+
+class WeChatBot(BaseChatBot):
+    """
+    微信机器人适配器。
+
+    配置要求(根据模式不同):
+      - WxPusher 模式 (mode="wxpusher"):
+        - app_id: WxPusher 应用 Token (appToken)
+        - app_secret: WxPusher 应用 Secret (用于回调验证)
+
+      - HTTP 桥接模式 (mode="http_bridge"):
+        - token: HTTP 桥接 API 地址 (如 http://localhost:3000)
+        - extra.callback_port: 回调监听端口，默认 8100
+        - extra.callback_token: 回调验证 Token
+
+      - 企业微信 Webhook (mode="wework_webhook"):
+        - token: Webhook Key (https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=xxx)
+
+    额外配置 (kwargs):
+      - mode: "wxpusher" | "http_bridge" | "wework_webhook"
+    """
+
+    platform_name = "wechat"
+
+    def __init__(self, app_id: str = "", app_secret: str = "", **kwargs):
+        super().__init__(**kwargs)
+        self.app_id = app_id
+        self.app_secret = app_secret
+        self._session: Optional[aiohttp.ClientSession] = None
+        self._mode = kwargs.get("mode", "")
+
+        # 根据配置自动选择模式
+        if not self._mode:
+            if app_id:
+                self._mode = "wxpusher"
+            elif self.token:
+                # 判断是否为企业微信 Webhook URL
+                if "qyapi.weixin.qq.com" in self.token:
+                    self._mode = "wework_webhook"
+                else:
+                    self._mode = "http_bridge"
+            else:
+                self._mode = "http_bridge"
+
+        # HTTP 桥接模式的回调配置
+        self._callback_port = kwargs.get("callback_port", 8100)
+        self._callback_token = kwargs.get("callback_token", "")
+        # 消息去重
+        self._processed_msg_ids: Dict[str, float] = {}
+
+    async def start(self):
+        """启动微信机器人"""
+        if not HAS_AIOHTTP:
+            self.logger.error("请安装 aiohttp: pip install aiohttp")
+            return
+
+        self._session = aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10))
+        self._running = True
+
+        if self._mode == "wxpusher":
+            await self._start_wxpusher()
+        elif self._mode == "http_bridge":
+            await self._start_http_bridge()
+        elif self._mode == "wework_webhook":
+            self.logger.info("企业微信 Webhook 模式已启动 (仅支持推送)")
+            while self._running:
+                await asyncio.sleep(1)
+        else:
+            self.logger.warning(f"未知模式: {self._mode}")
+            while self._running:
+                await asyncio.sleep(1)
+
+    async def stop(self):
+        """停止微信机器人"""
+        self._running = False
+        if self._session:
+            await self._session.close()
+        self.logger.info("微信机器人已停止")
+
+    async def send_message(self, response: ChatResponse) -> bool:
+        """发送消息到微信"""
+        if not self._session:
+            return False
+
+        try:
+            if self._mode == "wxpusher":
+                return await self._send_wxpusher(response)
+            elif self._mode == "http_bridge":
+                return await self._send_http_bridge(response)
+            elif self._mode == "wework_webhook":
+                return await self._send_wework_webhook(response)
+            else:
+                self.logger.error(f"不支持的发送模式: {self._mode}")
+                return False
+        except Exception as e:
+            self.logger.error(f"微信发送消息异常: {e}")
+            return False
+
+    # ==========================================================================
+    # WxPusher 模式
+    # ==========================================================================
+
+    async def _start_wxpusher(self):
+        """启动 WxPusher 模式（含消息接收回调服务器）"""
+        if not self.app_id:
+            self.logger.error("WxPusher 模式需要配置 app_id (appToken)")
+            return
+
+        self.logger.info(
+            f"微信机器人(WxPusher 模式)已启动 - AppToken: {self.app_id[:8]}..."
+        )
+
+        # 如果配置了 app_secret，启动回调服务器接收用户消息
+        if self.app_secret:
+            asyncio.create_task(self._wxpusher_callback_server())
+            self.logger.info(f"WxPusher 回调服务器已启动: 0.0.0.0:{self._callback_port}")
+        else:
+            self.logger.warning(
+                "WxPusher 模式未配置 app_secret，无法接收用户消息。"
+                "如需双向通信，请在 WxPusher 管理后台配置回调地址。"
+            )
+
+        while self._running:
+            await asyncio.sleep(1)
+
+    async def _wxpusher_callback_server(self):
+        """WxPusher 消息接收回调服务器"""
+        try:
+            from aiohttp import web
+        except ImportError:
+            self.logger.error("需要 aiohttp: pip install aiohttp")
+            return
+
+        app = web.Application()
+        app.router.add_post("/wxpusher/callback", self._handle_wxpusher_callback)
+        app.router.add_get("/wxpusher/health", self._health_check)
+
+        runner = web.AppRunner(app)
+        await runner.setup()
+        site = web.TCPSite(runner, "0.0.0.0", self._callback_port)
+        await site.start()
+
+        while self._running:
+            await asyncio.sleep(1)
+
+    async def _handle_wxpusher_callback(self, request):
+        """处理 WxPusher 消息回调"""
+        try:
+            from aiohttp import web
+            data = await request.json()
+
+            # WxPusher 验证签名
+            signature = request.headers.get("Signature", "")
+            if signature and self.app_secret:
+                body = await request.text()
+                expected = self._wxpusher_sign(body, self.app_secret)
+                if signature != expected:
+                    self.logger.warning("WxPusher 签名验证失败")
+                    return web.json_response({"code": -1, "msg": "签名错误"})
+
+            action = data.get("action", "")
+            data_type = data.get("type", "")
+
+            # 验证消息（首次配置回调时的验证请求）
+            if action == "appVerify":
+                verify_token = data.get("data", {}).get("verifyToken", "")
+                if verify_token == self.app_secret:
+                    return web.json_response({"code": 0, "msg": "ok"})
+                return web.json_response({"code": -1, "msg": "验证失败"})
+
+            # 处理用户消息
+            if data_type == "msg":
+                msg_data = data.get("data", {})
+                user_id = msg_data.get("from", "")
+                msg_id = msg_data.get("msgId", "")
+                content = msg_data.get("content", "")
+
+                if self._is_duplicate_msg(msg_id):
+                    return web.json_response({"code": 0})
+
+                self._mark_msg_processed(msg_id)
+
+                # 消息内容解析
+                # WxPusher content 格式: {"type":"text","content":"xxx"} 或纯文本
+                if isinstance(content, str):
+                    try:
+                        content_obj = json.loads(content)
+                        text = content_obj.get("content", content)
+                    except json.JSONDecodeError:
+                        text = content
+                else:
+                    text = str(content)
+
+                if not text.strip():
+                    return web.json_response({"code": 0})
+
+                message = ChatMessage(
+                    platform=self.platform_name,
+                    chat_id=f"wxpusher_{user_id}",
+                    user_id=user_id,
+                    username=msg_data.get("fromName", user_id),
+                    text=text.strip(),
+                    is_group=False,
+                    raw_data={"wxpusher_data": msg_data},
+                )
+
+                # 异步处理消息
+                asyncio.create_task(self._handle_message(message))
+
+            return web.json_response({"code": 0, "msg": "success"})
+
+        except Exception as e:
+            self.logger.error(f"WxPusher 回调处理失败: {e}")
+            from aiohttp import web
+            return web.json_response({"code": -1, "msg": str(e)})
+
+    async def _send_wxpusher(self, response: ChatResponse) -> bool:
+        """通过 WxPusher 发送消息"""
+        if not self.app_id:
+            return False
+
+        url = "https://wxpusher.zjiecode.com/api/send/message"
+        payload = {
+            "appToken": self.app_id,
+            "content": response.text[:5000],
+            "contentType": 1,  # 1=文本, 2=HTML, 3=Markdown
+            "uids": [response.user_id] if response.user_id else [],
+            "topicIds": [],
+        }
+
+        # 如果是回复消息，添加引用
+        if response.reply_to:
+            payload["reference"] = {
+                "msgId": response.reply_to,
+                "type": 1,
+            }
+
+        async with self._session.post(url, json=payload) as resp:
+            result = await resp.json()
+            if result.get("code") == 1000:
+                return True
+            self.logger.error(f"WxPusher 发送失败: {result}")
+            return False
+
+    @staticmethod
+    def _wxpusher_sign(body: str, token: str) -> str:
+        """WxPusher 签名计算"""
+        return hashlib.sha1(f"{body}{token}".encode()).hexdigest()
+
+    # ==========================================================================
+    # HTTP 桥接模式
+    # ==========================================================================
+
+    async def _start_http_bridge(self):
+        """启动 HTTP 桥接模式"""
+        bridge_url = self.token or ""
+        if not bridge_url:
+            self.logger.warning(
+                "HTTP 桥接模式未配置 API 地址 (token)。"
+                "请设置微信桥接服务的地址 (如 http://localhost:3000)。"
+            )
+        else:
+            self.logger.info(f"微信机器人(HTTP 桥接模式)已启动: {bridge_url}")
+
+        # 启动回调接收服务器
+        asyncio.create_task(self._bridge_callback_server())
+
+        while self._running:
+            await asyncio.sleep(1)
+
+    async def _bridge_callback_server(self):
+        """HTTP 桥接回调服务器"""
+        try:
+            from aiohttp import web
+        except ImportError:
+            self.logger.error("需要 aiohttp: pip install aiohttp")
+            return
+
+        app = web.Application()
+        app.router.add_post("/wechat/callback", self._handle_bridge_callback)
+        app.router.add_get("/wechat/health", self._health_check)
+
+        runner = web.AppRunner(app)
+        await runner.setup()
+        site = web.TCPSite(runner, "0.0.0.0", self._callback_port)
+        await site.start()
+        self.logger.info(
+            f"微信桥接回调服务器已启动: http://0.0.0.0:{self._callback_port}/wechat/callback"
+        )
+
+        while self._running:
+            await asyncio.sleep(1)
+
+    async def _handle_bridge_callback(self, request):
+        """
+        处理 HTTP 桥接回调。
+
+        兼容多种桥接协议格式:
+        - wechaty-puppet: {"from": "xxx", "to": "xxx", "text": "xxx", "room": "..."}
+        - comwechat: {"data": {"fromUser": "xxx", "toUser": "xxx", "content": "xxx"}}
+        - 通用格式: {"user_id": "xxx", "message": "xxx", "group_id": "..."}
+        """
+        try:
+            from aiohttp import web
+            data = await request.json()
+
+            # Token 验证
+            if self._callback_token:
+                auth = request.headers.get("Authorization", "")
+                if auth != f"Bearer {self._callback_token}":
+                    self.logger.warning("桥接回调 Token 验证失败")
+                    return web.json_response({"code": 403})
+
+            # 尝试多种格式解析
+            message = self._parse_bridge_message(data)
+            if message and message.text.strip():
+                asyncio.create_task(self._handle_message(message))
+
+            return web.json_response({"code": 0})
+
+        except Exception as e:
+            self.logger.error(f"桥接回调处理失败: {e}")
+            from aiohttp import web
+            return web.json_response({"code": 500, "msg": str(e)})
+
+    def _parse_bridge_message(self, data: dict) -> Optional[ChatMessage]:
+        """
+        解析桥接消息，兼容多种协议格式。
+
+        支持的格式:
+        1. wechaty: {"from": "wxid_xxx", "text": "hello", "room": "roomid"}
+        2. comwechat: {"data": {"fromUser": "wxid_xxx", "content": "hello", "isGroup": 0}}
+        3. 通用: {"user_id": "xxx", "message": "xxx", "group_id": "xxx"}
+        """
+        text = ""
+        user_id = ""
+        chat_id = ""
+        username = ""
+        is_group = False
+        msg_id = ""
+
+        # 格式1: wechaty-puppet
+        if "from" in data and "text" in data:
+            user_id = data["from"]
+            text = data["text"]
+            room = data.get("room", "")
+            is_group = bool(room)
+            chat_id = room if room else user_id
+            username = data.get("name", data.get("from", ""))
+            msg_id = data.get("id", "")
+
+        # 格式2: comwechat
+        elif "data" in data:
+            inner = data["data"]
+            user_id = inner.get("fromUser", inner.get("fromGroup", ""))
+            text = inner.get("content", inner.get("msg", ""))
+            chat_id = inner.get("toUser", "")
+            is_group = inner.get("isGroup", 0) == 1
+            if is_group:
+                chat_id = inner.get("fromGroup", chat_id)
+            else:
+                chat_id = user_id
+            username = inner.get("fromName", user_id)
+            msg_id = inner.get("msgId", inner.get("newMsgId", ""))
+
+        # 格式3: 通用格式
+        elif "user_id" in data or "message" in data:
+            user_id = data.get("user_id", "")
+            text = data.get("message", data.get("text", data.get("content", "")))
+            chat_id = data.get("group_id", data.get("chat_id", user_id))
+            is_group = bool(data.get("group_id", ""))
+            username = data.get("username", user_id)
+            msg_id = data.get("msg_id", "")
+
+        else:
+            self.logger.debug(f"无法识别的桥接消息格式: {list(data.keys())}")
+            return None
+
+        if self._is_duplicate_msg(msg_id):
+            return None
+        self._mark_msg_processed(msg_id)
+
+        return ChatMessage(
+            platform=self.platform_name,
+            chat_id=chat_id,
+            user_id=user_id,
+            username=username,
+            text=text.strip(),
+            is_group=is_group,
+            reply_to=msg_id,
+            raw_data={"bridge_data": data},
+        )
+
+    async def _send_http_bridge(self, response: ChatResponse) -> bool:
+        """通过 HTTP 桥接发送消息"""
+        if not self.token:
+            return False
+
+        base_url = self.token.rstrip("/")
+        headers = {}
+        if self._callback_token:
+            headers["Authorization"] = f"Bearer {self._callback_token}"
+
+        payload = {
+            "to": response.user_id or response.chat_id,
+            "message": response.text,
+            "type": "text",
+        }
+
+        # 群聊消息需要指定群
+        if hasattr(response, "metadata") and response.metadata.get("is_group"):
+            payload["room"] = response.chat_id
+            payload["to"] = response.user_id  # @指定用户或空
+
+        try:
+            async with self._session.post(
+                f"{base_url}/send",
+                json=payload,
+                headers=headers,
+            ) as resp:
+                if resp.status == 200:
+                    result = await resp.json()
+                    if result.get("code", 0) == 0 or result.get("success", True):
+                        return True
+                self.logger.error(f"HTTP 桥接发送失败: {resp.status}")
+                return False
+        except Exception as e:
+            self.logger.error(f"HTTP 桥接发送异常: {e}")
+            return False
+
+    # ==========================================================================
+    # 企业微信 Webhook 模式
+    # ==========================================================================
+
+    async def _send_wework_webhook(self, response: ChatResponse) -> bool:
+        """通过企业微信 Webhook 发送"""
+        if not self.token:
+            return False
+
+        # 支持 Webhook Key 或完整 URL
+        if self.token.startswith("http"):
+            url = self.token
+        else:
+            url = f"https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key={self.token}"
+
+        # 支持 Markdown 格式
+        msg_type = "markdown" if response.parse_mode == "markdown" else "text"
+        payload: Dict[str, Any] = {
+            "msgtype": msg_type,
+            msg_type: {
+                "content": response.text[:4096],
+            },
+        }
+
+        # 支持提及指定人
+        if response.user_id:
+            mentioned_list = [response.user_id]
+            if msg_type == "text":
+                payload["text"]["mentioned_list"] = mentioned_list
+
+        async with self._session.post(url, json=payload) as resp:
+            result = await resp.json()
+            if result.get("errcode") == 0:
+                return True
+            self.logger.error(f"企业微信 Webhook 发送失败: {result}")
+            return False
+
+    # ==========================================================================
+    # 辅助方法
+    # ==========================================================================
+
+    async def _health_check(self, request):
+        """健康检查端点"""
+        from aiohttp import web
+        return web.json_response({
+            "status": "ok",
+            "mode": self._mode,
+            "running": self._running,
+        })
+
+    def _is_duplicate_msg(self, msg_id: str) -> bool:
+        """消息去重检查"""
+        if not msg_id:
+            return False
+        return msg_id in self._processed_msg_ids
+
+    def _mark_msg_processed(self, msg_id: str):
+        """标记消息已处理"""
+        if not msg_id:
+            return
+        self._processed_msg_ids[msg_id] = time.time()
+        # 清理 5 分钟前的记录
+        now = time.time()
+        expired = [
+            mid for mid, ts in self._processed_msg_ids.items()
+            if now - ts > 300
+        ]
+        for mid in expired:
+            del self._processed_msg_ids[mid]
+
+    async def send_markdown(self, response: ChatResponse) -> bool:
+        """发送 Markdown 格式消息（WxPusher/企业微信支持）"""
+        response_copy = ChatResponse(
+            chat_id=response.chat_id,
+            user_id=response.user_id,
+            text=response.text,
+            parse_mode="markdown",
+            reply_to=response.reply_to,
+            metadata=response.metadata,
+        )
+        # WxPusher 支持内容类型 3=Markdown
+        if self._mode == "wxpusher":
+            try:
+                url = "https://wxpusher.zjiecode.com/api/send/message"
+                payload = {
+                    "appToken": self.app_id,
+                    "content": response.text[:5000],
+                    "contentType": 3,  # Markdown
+                    "uids": [response.user_id] if response.user_id else [],
+                }
+                async with self._session.post(url, json=payload) as resp:
+                    result = await resp.json()
+                    return result.get("code") == 1000
+            except Exception as e:
+                self.logger.error(f"WxPusher Markdown 发送失败: {e}")
+                return False
+        return await self.send_message(response_copy)

package/communication/__init__.py

@@ -0,0 +1,66 @@
+"""
+communication - Agent-to-Agent Encrypted Communication Module
+==============================================================
+Provides end-to-end encrypted messaging between MyAgent instances using:
+- Ed25519 for identity (signing, agent ID)
+- X25519 for key exchange (Diffie-Hellman)
+- AES-256-GCM for message encryption
+- WebSocket for real-time remote messaging (AICQ relay)
+- asyncio queues for local same-machine messaging
+"""
+
+from .crypto import (
+    generate_ed25519_keypair,
+    generate_agent_id,
+    generate_x25519_keypair,
+    ed25519_to_x25519_private,
+    ed25519_to_x25519_public,
+    x25519_key_exchange,
+    derive_shared_key,
+    encrypt,
+    decrypt,
+    encrypt_message,
+    decrypt_message,
+    sign,
+    verify,
+    serialize_public_key,
+    deserialize_public_key,
+    serialize_private_key,
+    deserialize_private_key,
+    _HAS_CRYPTOGRAPHY,
+)
+
+from .peer import Peer, PeerStore
+from .channel import Message, LocalChannel, RemoteChannel
+from .manager import CommunicationManager
+
+__all__ = [
+    # Crypto
+    "generate_ed25519_keypair",
+    "generate_agent_id",
+    "generate_x25519_keypair",
+    "ed25519_to_x25519_private",
+    "ed25519_to_x25519_public",
+    "x25519_key_exchange",
+    "derive_shared_key",
+    "encrypt",
+    "decrypt",
+    "encrypt_message",
+    "decrypt_message",
+    "sign",
+    "verify",
+    "serialize_public_key",
+    "deserialize_public_key",
+    "serialize_private_key",
+    "deserialize_private_key",
+    "_HAS_CRYPTOGRAPHY",
+    # Peer
+    "Peer",
+    "PeerStore",
+    # Channel
+    "Message",
+    "LocalChannel",
+    "RemoteChannel",
+    # Manager
+    "CommunicationManager",
+]