myagent-ai 1.0.0

package/chatbot/discord_bot.py

@@ -0,0 +1,146 @@
+"""
+chatbot/discord_bot.py - Discord 机器人
+=========================================
+使用 discord.py 库接入 Discord。
+纯 Python 异步实现。
+"""
+from __future__ import annotations
+
+import asyncio
+from typing import Optional, List
+
+from chatbot.base import BaseChatBot, ChatMessage, ChatResponse
+
+try:
+    import discord
+    HAS_DISCORD = True
+except ImportError:
+    HAS_DISCORD = False
+
+
+class DiscordBot(BaseChatBot):
+    """
+    Discord 机器人适配器。
+
+    配置要求:
+      - token: Bot Token (从 Discord Developer Portal 获取)
+    """
+
+    platform_name = "discord"
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._client: Optional[discord.Client] = None
+        self._intents = discord.Intents.default()
+        self._intents.message_content = True
+        self._intents.members = True
+
+    async def start(self):
+        """启动 Discord 机器人"""
+        if not HAS_DISCORD:
+            self.logger.error("请安装 discord.py: pip install discord.py")
+            return
+
+        if not self.token:
+            self.logger.error("Discord Bot Token 未配置")
+            return
+
+        self._client = discord.Client(intents=self._intents)
+
+        @self._client.event
+        async def on_ready():
+            self.logger.info(f"Discord 机器人已登录: {self._client.user}")
+            await self._client.change_presence(
+                activity=discord.Activity(
+                    type=discord.ActivityType.listening,
+                    name="MyAgent"
+                )
+            )
+
+        @self._client.event
+        async def on_message(message: discord.Message):
+            # 忽略自己的消息
+            if message.author == self._client.user:
+                return
+
+            # 只处理 Bot 被提及或私信
+            is_dm = isinstance(message.channel, discord.DMChannel)
+            is_mentioned = self._client.user.mentioned_in(message)
+            has_prefix = message.content.startswith("!")
+
+            if not (is_dm or is_mentioned or has_prefix):
+                return
+
+            # 去除 @提及 和前缀
+            text = message.content
+            text = text.replace(f"<@{self._client.user.id}>", "").strip()
+            text = text.replace(f"<@!{self._client.user.id}>", "").strip()
+            if text.startswith("!"):
+                text = text[1:].strip()
+
+            if not text:
+                return
+
+            chat_message = ChatMessage(
+                platform=self.platform_name,
+                chat_id=str(message.channel.id),
+                user_id=str(message.author.id),
+                username=message.author.display_name,
+                text=text,
+                is_group=not is_dm,
+                reply_to=str(message.reference.message_id) if message.reference else "",
+                raw_data={
+                    "guild_id": str(message.guild.id) if message.guild else "",
+                    "channel_id": str(message.channel.id),
+                },
+            )
+            await self._handle_message(chat_message)
+
+        self._running = True
+        try:
+            await self._client.start(self.token)
+        except Exception as e:
+            self.logger.error(f"Discord 机器人启动失败: {e}")
+            self._running = False
+
+    async def stop(self):
+        """停止 Discord 机器人"""
+        self._running = False
+        if self._client:
+            await self._client.close()
+        self.logger.info("Discord 机器人已停止")
+
+    async def send_message(self, response: ChatResponse) -> bool:
+        """发送消息到 Discord"""
+        if not self._client or not self._client.is_ready() or not response.chat_id:
+            return False
+
+        try:
+            channel = self._client.get_channel(int(response.chat_id))
+            if not channel:
+                channel = self._client.get_user(int(response.chat_id))
+
+            if not channel:
+                self.logger.error(f"无法找到频道/用户: {response.chat_id}")
+                return False
+
+            # Discord 消息长度限制 2000
+            text = response.text
+            if len(text) > 2000:
+                # 分段发送
+                chunks = [text[i:i+2000] for i in range(0, len(text), 2000)]
+                for chunk in chunks:
+                    if isinstance(channel, discord.abc.Messageable):
+                        await channel.send(chunk)
+                    else:
+                        await channel.send(chunk)
+            else:
+                if isinstance(channel, discord.abc.Messageable):
+                    await channel.send(text)
+                else:
+                    await channel.send(text)
+
+            return True
+        except Exception as e:
+            self.logger.error(f"发送消息失败: {e}")
+            return False

package/chatbot/feishu_bot.py

@@ -0,0 +1,548 @@
+"""
+chatbot/feishu_bot.py - 飞书机器人
+===================================
+使用飞书开放平台 SDK 接入飞书。
+纯 Python 异步实现，支持:
+  - WebSocket 长连接模式接收事件（推荐）
+  - HTTP 回调模式接收事件（备用，需公网地址）
+  - HTTP API 发送消息
+"""
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import hmac
+import json
+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 FeishuBot(BaseChatBot):
+    """
+    飞书机器人适配器。
+
+    配置要求:
+      - app_id: 应用 ID
+      - app_secret: 应用密钥
+
+    支持模式:
+      - ws: WebSocket 长连接（默认，推荐，无需公网地址）
+      - webhook: HTTP 回调（需要公网地址和 verify_key）
+      - polling: 轮询模式（兜底）
+
+    额外配置 (kwargs):
+      - receive_mode: "ws" | "webhook" | "polling"，默认 "ws"
+      - verification_token: 事件订阅验证令牌（webhook 模式需要）
+      - encrypt_key: 事件加密密钥（可选）
+    """
+
+    platform_name = "feishu"
+    API_BASE = "https://open.feishu.cn/open-apis"
+
+    def __init__(self, app_id: str = "", app_secret: str = "", **kwargs):
+        super().__init__(**kwargs)
+        self.app_id = app_id
+        self.app_secret = app_secret
+        self._tenant_access_token = ""
+        self._token_expires = 0
+        self._session: Optional[aiohttp.ClientSession] = None
+        self._ws_session: Optional[aiohttp.ClientWebSocketResponse] = None
+        self._receive_mode = kwargs.get("receive_mode", "ws")
+        self._verification_token = kwargs.get("verification_token", "")
+        self._encrypt_key = kwargs.get("encrypt_key", "")
+        self._process_tasks: set = set()
+        # 消息去重（飞书可能重复推送）
+        self._processed_events: Dict[str, float] = {}
+        self._dedup_window = 300  # 5 分钟去重窗口
+
+    async def start(self):
+        """启动飞书机器人"""
+        if not HAS_AIOHTTP:
+            self.logger.error("请安装 aiohttp: pip install aiohttp")
+            return
+
+        if not self.app_id or not self.app_secret:
+            self.logger.error("飞书 App ID / App Secret 未配置")
+            return
+
+        self._session = aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=30))
+        self._running = True
+
+        # 获取 tenant_access_token
+        await self._refresh_token()
+
+        if self._receive_mode == "ws":
+            asyncio.create_task(self._ws_listen())
+            self.logger.info("飞书机器人已启动 (WebSocket 长连接模式)")
+        elif self._receive_mode == "webhook":
+            asyncio.create_task(self._webhook_server())
+            self.logger.info("飞书机器人已启动 (Webhook 回调模式)")
+        else:
+            asyncio.create_task(self._poll_listen())
+            self.logger.info("飞书机器人已启动 (轮询模式)")
+
+        # 保持运行
+        while self._running:
+            await asyncio.sleep(1)
+
+    async def stop(self):
+        """停止飞书机器人"""
+        self._running = False
+        # 关闭 WebSocket
+        if self._ws_session:
+            try:
+                await self._ws_session.close()
+            except Exception:
+                pass
+        # 取消所有消息处理任务
+        for task in self._process_tasks:
+            task.cancel()
+        self._process_tasks.clear()
+        if self._session:
+            await self._session.close()
+        self.logger.info("飞书机器人已停止")
+
+    async def send_message(self, response: ChatResponse) -> bool:
+        """发送消息到飞书"""
+        if not self._session or not response.chat_id:
+            return False
+
+        await self._ensure_token()
+
+        try:
+            url = f"{self.API_BASE}/im/v1/messages"
+            headers = {
+                "Authorization": f"Bearer {self._tenant_access_token}",
+                "Content-Type": "application/json",
+            }
+            payload = {
+                "receive_id": response.chat_id,
+                "msg_type": "text",
+                "content": json.dumps({"text": response.text[:5000]}, ensure_ascii=False),
+            }
+            params = {"receive_id_type": "chat_id"}
+
+            async with self._session.post(url, headers=headers, json=payload,
+                                           params=params) as resp:
+                result = await resp.json()
+                if result.get("code") != 0:
+                    self.logger.error(f"飞书发送失败: {result}")
+                    return False
+                return True
+        except Exception as e:
+            self.logger.error(f"飞书发送消息异常: {e}")
+            return False
+
+    # ==========================================================================
+    # WebSocket 长连接模式（推荐）
+    # ==========================================================================
+
+    async def _ws_listen(self):
+        """通过 WebSocket 长连接接收事件"""
+        reconnect_delay = 1
+        max_reconnect_delay = 30
+
+        while self._running:
+            try:
+                await self._ensure_token()
+
+                # 获取 WebSocket 长连接地址
+                ws_url = await self._get_ws_endpoint()
+                if not ws_url:
+                    self.logger.error("获取 WebSocket 地址失败，5秒后重试")
+                    await asyncio.sleep(5)
+                    continue
+
+                self.logger.info(f"正在连接飞书 WebSocket: {ws_url[:80]}...")
+
+                headers = {"Authorization": f"Bearer {self._tenant_access_token}"}
+                async with self._session.ws_connect(
+                    ws_url,
+                    headers=headers,
+                    heartbeat=30,
+                    max_msg_size=1024 * 1024 * 10,  # 10MB
+                ) as ws:
+                    self._ws_session = ws
+                    reconnect_delay = 1  # 连接成功后重置重连间隔
+                    self.logger.info("飞书 WebSocket 已连接")
+
+                    async for msg in ws:
+                        if not self._running:
+                            break
+                        if msg.type == aiohttp.WSMsgType.TEXT:
+                            try:
+                                data = json.loads(msg.data)
+                                await self._handle_ws_event(data)
+                            except json.JSONDecodeError as e:
+                                self.logger.warning(f"WS 消息解析失败: {e}")
+                        elif msg.type in (aiohttp.WSMsgType.CLOSED,
+                                          aiohttp.WSMsgType.ERROR):
+                            self.logger.warning(f"WebSocket 连接关闭: {msg.type}")
+                            break
+                        elif msg.type == aiohttp.WSMsgType.PING:
+                            await ws.pong()
+
+            except aiohttp.ClientError as e:
+                self.logger.error(f"飞书 WebSocket 连接异常: {e}")
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                self.logger.error(f"飞书 WebSocket 未知异常: {e}")
+
+            # 指数退避重连
+            self._ws_session = None
+            if self._running:
+                self.logger.info(f"{reconnect_delay}秒后重连...")
+                await asyncio.sleep(reconnect_delay)
+                reconnect_delay = min(reconnect_delay * 2, max_reconnect_delay)
+
+    async def _get_ws_endpoint(self) -> str:
+        """获取 WebSocket 长连接端点地址"""
+        try:
+            url = f"{self.API_BASE}/im/v1/events/ws"
+            headers = {"Authorization": f"Bearer {self._tenant_access_token}"}
+            async with self._session.get(url, headers=headers) as resp:
+                result = await resp.json()
+                if result.get("code") == 0:
+                    ws_url = result.get("data", {}).get("url", "")
+                    if ws_url:
+                        return ws_url
+                    self.logger.error(f"WS 响应无 URL: {result}")
+                else:
+                    self.logger.error(f"获取 WS 端点失败: {result}")
+        except Exception as e:
+            self.logger.error(f"获取 WS 端点异常: {e}")
+        return ""
+
+    async def _handle_ws_event(self, data: dict):
+        """处理 WebSocket 事件"""
+        # 飞书 WebSocket 推送格式:
+        # {"schema": "2.0", "header": {...}, "event": {...}, "url": "..."}
+        schema = data.get("schema", "")
+
+        if schema == "2.0":
+            # 肯定应答 (ACK) - 必须在收到事件后立即返回
+            if "url" in data:
+                ack_url = data["url"]
+                asyncio.create_task(self._send_ws_ack(ack_url))
+
+            # 解析事件
+            event = data.get("event", {})
+            header = data.get("header", {})
+
+            # 消息接收事件
+            if header.get("event_type") == "im.message.receive_v1":
+                event_id = header.get("event_id", "")
+                if self._is_duplicate(event_id):
+                    self.logger.debug(f"重复事件已忽略: {event_id}")
+                    return
+
+                self._mark_processed(event_id)
+                asyncio.create_task(self._process_message_event(event))
+
+            # 其他事件类型
+            elif header.get("event_type"):
+                self.logger.debug(
+                    f"收到非消息事件: {header.get('event_type')}"
+                )
+
+        elif schema == "3.0":
+            # schema 3.0 - 包含 challenge 验证
+            header = data.get("header", {})
+            event_type = header.get("event_type", "")
+            if event_type == "connection":
+                # 连接建立确认
+                self.logger.info("飞书 WebSocket 连接确认已收到")
+
+    async def _send_ws_ack(self, ack_url: str):
+        """发送 WebSocket 事件确认"""
+        try:
+            async with self._session.post(ack_url) as resp:
+                if resp.status == 200:
+                    self.logger.debug("WS 事件 ACK 已发送")
+                else:
+                    text = await resp.text()
+                    self.logger.warning(f"WS ACK 失败 ({resp.status}): {text}")
+        except Exception as e:
+            self.logger.error(f"WS ACK 异常: {e}")
+
+    async def _process_message_event(self, event: dict):
+        """处理消息事件，转换为 ChatMessage 并分发"""
+        try:
+            # 解析飞书消息结构
+            sender = event.get("sender", {})
+            sender_id = sender.get("sender_id", {})
+            user_id = sender_id.get("user_id", "")
+            sender_type = sender_id.get("union_id", "")
+            chat_id = event.get("message", {}).get("chat_id", "")
+            message_id = event.get("message", {}).get("message_id", "")
+            msg_type = event.get("message", {}).get("msg_type", "text")
+            content_str = event.get("message", {}).get("content", "{}")
+
+            # 解析消息内容
+            try:
+                content = json.loads(content_str)
+                text = content.get("text", "")
+            except json.JSONDecodeError:
+                text = content_str
+
+            # 只处理文本消息（图片、文件等暂不支持）
+            if msg_type not in ("text", "post"):
+                if msg_type == "post":
+                    # 富文本消息，提取纯文本
+                    try:
+                        post_content = json.loads(content_str)
+                        text = self._extract_post_text(post_content)
+                    except Exception:
+                        text = "[富文本消息]"
+                else:
+                    self.logger.debug(f"忽略非文本消息类型: {msg_type}")
+                    return
+
+            # 忽略机器人自己的消息
+            if user_id == self.app_id:
+                return
+
+            # 判断是否群聊
+            chat_type = event.get("message", {}).get("chat_type", "p2p")
+            is_group = chat_type == "group"
+
+            # 构建统一消息格式
+            message = ChatMessage(
+                platform=self.platform_name,
+                chat_id=chat_id,
+                user_id=user_id,
+                username=sender_type or user_id,
+                text=text.strip(),
+                is_group=is_group,
+                reply_to=message_id,
+                raw_data={"event": event, "msg_type": msg_type},
+            )
+
+            # 异步处理消息
+            await self._handle_message(message)
+
+        except Exception as e:
+            self.logger.error(f"处理飞书消息事件失败: {e}")
+
+    def _extract_post_text(self, post_content: dict) -> str:
+        """从飞书富文本消息中提取纯文本"""
+        try:
+            title = post_content.get("title", "")
+            content = post_content.get("content", [])
+            texts = []
+            for node in content:
+                if isinstance(node, list):
+                    for item in node:
+                        if isinstance(item, dict) and item.get("tag") == "text":
+                            texts.append(item.get("text", ""))
+                elif isinstance(node, dict) and node.get("tag") == "text":
+                    texts.append(node.get("text", ""))
+            body = "".join(texts)
+            return f"{title}\n{body}" if title else body
+        except Exception:
+            return "[富文本消息]"
+
+    # ==========================================================================
+    # Webhook 回调模式（备用）
+    # ==========================================================================
+
+    async def _webhook_server(self):
+        """启动简单的 HTTP 服务器接收 webhook 回调"""
+        try:
+            from aiohttp import web
+        except ImportError:
+            self.logger.error("Webhook 模式需要 aiohttp: pip install aiohttp")
+            return
+
+        app = web.Application()
+        app.router.add_post("/feishu/webhook", self._handle_webhook)
+
+        runner = web.AppRunner(app)
+        await runner.setup()
+        port = self.config.get("webhook_port", 8080)
+        site = web.TCPSite(runner, "0.0.0.0", port)
+        await site.start()
+        self.logger.info(f"飞书 Webhook 服务器已启动: http://0.0.0.0:{port}/feishu/webhook")
+
+        while self._running:
+            await asyncio.sleep(1)
+
+    async def _handle_webhook(self, request):
+        """处理飞书 webhook 回调"""
+        try:
+            from aiohttp import web
+            data = await request.json()
+
+            # URL 验证（首次配置时飞书会发 challenge）
+            if "challenge" in data:
+                return web.json_response({"challenge": data["challenge"]})
+
+            # 事件验证
+            if self._verification_token:
+                token = data.get("header", {}).get("token", "")
+                if token != self._verification_token:
+                    self.logger.warning("Webhook 验证令牌不匹配")
+                    return web.json_response({"code": 403})
+
+            # 解析事件
+            event = data.get("event", {})
+            header = data.get("header", {})
+            event_type = header.get("event_type", "")
+            event_id = header.get("event_id", "")
+
+            if event_type == "im.message.receive_v1":
+                if self._is_duplicate(event_id):
+                    return web.json_response({"code": 0})
+                self._mark_processed(event_id)
+                asyncio.create_task(self._process_message_event(event))
+
+            return web.json_response({"code": 0})
+
+        except Exception as e:
+            self.logger.error(f"Webhook 处理失败: {e}")
+            from aiohttp import web
+            return web.json_response({"code": 500})
+
+    # ==========================================================================
+    # 轮询模式（兜底）
+    # ==========================================================================
+
+    async def _poll_listen(self):
+        """通过轮询获取消息（需要开启消息审核回调或使用第三方转发）"""
+        self.logger.warning(
+            "飞书轮询模式: 此模式需要额外的消息转发服务。"
+            "建议使用 WebSocket 模式或 Webhook 模式。"
+        )
+        poll_interval = 5
+        while self._running:
+            await asyncio.sleep(poll_interval)
+
+    # ==========================================================================
+    # 内部方法
+    # ==========================================================================
+
+    async def _refresh_token(self):
+        """刷新 tenant_access_token"""
+        try:
+            url = f"{self.API_BASE}/auth/v3/tenant_access_token/internal"
+            payload = {
+                "app_id": self.app_id,
+                "app_secret": self.app_secret,
+            }
+            async with self._session.post(url, json=payload) as resp:
+                result = await resp.json()
+                if result.get("code") == 0:
+                    self._tenant_access_token = result["tenant_access_token"]
+                    self._token_expires = time.time() + result.get("expire", 7200) - 300
+                    self.logger.debug("飞书 Token 已刷新")
+                else:
+                    self.logger.error(f"获取 Token 失败: {result}")
+        except Exception as e:
+            self.logger.error(f"刷新 Token 异常: {e}")
+
+    async def _ensure_token(self):
+        """确保 Token 有效"""
+        if time.time() > self._token_expires:
+            await self._refresh_token()
+
+    def _is_duplicate(self, event_id: str) -> bool:
+        """检查是否为重复事件"""
+        if not event_id:
+            return False
+        now = time.time()
+        if event_id in self._processed_events:
+            return True
+        return False
+
+    def _mark_processed(self, event_id: str):
+        """标记事件已处理"""
+        if not event_id:
+            return
+        self._processed_events[event_id] = time.time()
+        # 清理过期记录
+        now = time.time()
+        expired = [
+            eid for eid, ts in self._processed_events.items()
+            if now - ts > self._dedup_window
+        ]
+        for eid in expired:
+            del self._processed_events[eid]
+
+    # ==========================================================================
+    # 辅助方法
+    # ==========================================================================
+
+    async def get_chat_info(self, chat_id: str) -> Optional[dict]:
+        """获取群聊/单聊信息"""
+        await self._ensure_token()
+        try:
+            url = f"{self.API_BASE}/im/v1/chats/{chat_id}"
+            headers = {"Authorization": f"Bearer {self._tenant_access_token}"}
+            async with self._session.get(url, headers=headers) as resp:
+                result = await resp.json()
+                if result.get("code") == 0:
+                    return result.get("data", {})
+        except Exception as e:
+            self.logger.error(f"获取聊天信息失败: {e}")
+        return None
+
+    async def send_card_message(self, chat_id: str, card_content: dict) -> bool:
+        """
+        发送消息卡片（富文本交互卡片）。
+
+        Args:
+            chat_id: 聊天 ID
+            card_content: 飞书消息卡片 JSON 内容
+        """
+        await self._ensure_token()
+        try:
+            url = f"{self.API_BASE}/im/v1/messages"
+            headers = {
+                "Authorization": f"Bearer {self._tenant_access_token}",
+                "Content-Type": "application/json",
+            }
+            payload = {
+                "receive_id": chat_id,
+                "msg_type": "interactive",
+                "content": json.dumps(card_content, ensure_ascii=False),
+            }
+            params = {"receive_id_type": "chat_id"}
+            async with self._session.post(url, headers=headers, json=payload,
+                                           params=params) as resp:
+                result = await resp.json()
+                return result.get("code") == 0
+        except Exception as e:
+            self.logger.error(f"发送消息卡片失败: {e}")
+            return False
+
+    async def reply_message(self, message_id: str, text: str) -> bool:
+        """回复指定消息"""
+        await self._ensure_token()
+        try:
+            url = f"{self.API_BASE}/im/v1/messages/{message_id}/reply"
+            headers = {
+                "Authorization": f"Bearer {self._tenant_access_token}",
+                "Content-Type": "application/json",
+            }
+            payload = {
+                "msg_type": "text",
+                "content": json.dumps({"text": text[:5000]}, ensure_ascii=False),
+            }
+            async with self._session.post(url, headers=headers, json=payload) as resp:
+                result = await resp.json()
+                if result.get("code") == 0:
+                    return True
+                self.logger.error(f"飞书回复失败: {result}")
+                return False
+        except Exception as e:
+            self.logger.error(f"飞书回复消息异常: {e}")
+            return False