ErisPulse-QQBotAdapter 1.0.0__py3-none-any.whl

QQBotAdapter/Converter.py

@@ -0,0 +1,278 @@
+import time
+import uuid
+from datetime import datetime, timezone
+from typing import Dict, Optional, List
+
+
+class QQBotConverter:
+    def __init__(self, bot_id_getter=None):
+        self._bot_id_getter = bot_id_getter
+        self._event_type_map = {
+            "C2C_MESSAGE_CREATE": ("message", "private"),
+            "GROUP_AT_MESSAGE_CREATE": ("message", "group"),
+            "AT_MESSAGE_CREATE": ("message", "channel"),
+            "MESSAGE_CREATE": ("message", "channel"),
+            "DIRECT_MESSAGE_CREATE": ("message", "private"),
+            "FRIEND_ADD": ("notice", "friend_add"),
+            "FRIEND_DEL": ("notice", "friend_del"),
+            "C2C_MSG_REJECT": ("notice", "private_block"),
+            "C2C_MSG_RECEIVE": ("notice", "private_allow"),
+            "GROUP_ADD_ROBOT": ("notice", "group_increase"),
+            "GROUP_DEL_ROBOT": ("notice", "group_decrease"),
+            "GROUP_MSG_REJECT": ("notice", "group_block"),
+            "GROUP_MSG_RECEIVE": ("notice", "group_allow"),
+            "GUILD_CREATE": ("notice", "guild_create"),
+            "GUILD_UPDATE": ("notice", "guild_update"),
+            "GUILD_DELETE": ("notice", "guild_delete"),
+            "CHANNEL_CREATE": ("notice", "channel_create"),
+            "CHANNEL_UPDATE": ("notice", "channel_update"),
+            "CHANNEL_DELETE": ("notice", "channel_delete"),
+            "GUILD_MEMBER_ADD": ("notice", "group_member_increase"),
+            "GUILD_MEMBER_UPDATE": ("notice", "group_member_update"),
+            "GUILD_MEMBER_REMOVE": ("notice", "group_member_decrease"),
+            "MESSAGE_REACTION_ADD": ("notice", "qqbot_reaction_add"),
+            "MESSAGE_REACTION_REMOVE": ("notice", "qqbot_reaction_remove"),
+            "INTERACTION_CREATE": ("notice", "qqbot_interaction"),
+            "MESSAGE_AUDIT_PASS": ("notice", "qqbot_audit_pass"),
+            "MESSAGE_AUDIT_REJECT": ("notice", "qqbot_audit_reject"),
+            "AUDIO_START": ("notice", "qqbot_audio_start"),
+            "AUDIO_FINISH": ("notice", "qqbot_audio_finish"),
+            "AT_MESSAGE_DELETE": ("notice", "qqbot_message_delete"),
+            "PUBLIC_MESSAGE_DELETE": ("notice", "qqbot_message_delete"),
+            "DIRECT_MESSAGE_DELETE": ("notice", "qqbot_message_delete"),
+        }
+
+    def convert(self, raw_event: Dict, ws_event_type: str = "") -> Optional[Dict]:
+        if not isinstance(raw_event, dict):
+            return None
+
+        event_id = raw_event.get("id") or str(uuid.uuid4())
+
+        timestamp = raw_event.get("timestamp")
+        if timestamp:
+            event_time = self._parse_timestamp(timestamp)
+        else:
+            event_time = int(time.time())
+
+        raw_type = ws_event_type
+        if not raw_type:
+            for key in raw_event:
+                if key not in ("id", "timestamp", "version", "shard") and key.isupper():
+                    raw_type = key
+                    break
+
+        if not raw_type:
+            inner_data = raw_event.get("d", raw_event)
+            if isinstance(inner_data, dict):
+                for key in inner_data:
+                    if key.isupper() and "_" in key:
+                        raw_type = key
+                        break
+
+        event_info = self._event_type_map.get(raw_type, None)
+        if event_info is None:
+            return self._create_unknown_event(raw_event, event_id, raw_type or "unknown")
+
+        event_type, detail_type = event_info
+
+        base_event = {
+            "id": str(event_id),
+            "time": event_time,
+            "type": event_type,
+            "detail_type": detail_type,
+            "platform": "qqbot",
+            "self": {
+                "platform": "qqbot",
+                "user_id": self._bot_id_getter() if self._bot_id_getter else "",
+            },
+            "qqbot_raw": raw_event,
+            "qqbot_raw_type": raw_type,
+        }
+
+        handler = getattr(self, f"_handle_{event_type}", None)
+        if handler:
+            return handler(raw_event, base_event, raw_type)
+
+        return base_event
+
+    def _handle_message(self, raw_event: Dict, base_event: Dict, raw_type: str) -> Dict:
+        detail_type = base_event["detail_type"]
+
+        if raw_type == "C2C_MESSAGE_CREATE":
+            author = raw_event.get("author", {})
+            base_event["user_id"] = str(author.get("user_openid", ""))
+            base_event["user_nickname"] = ""
+            base_event["message_id"] = raw_event.get("id", "")
+            base_event["qqbot_openid"] = author.get("user_openid", "")
+        elif raw_type == "GROUP_AT_MESSAGE_CREATE":
+            author = raw_event.get("author", {})
+            base_event["user_id"] = str(author.get("member_openid", ""))
+            base_event["user_nickname"] = ""
+            base_event["group_id"] = raw_event.get("group_openid", "")
+            base_event["message_id"] = raw_event.get("id", "")
+            base_event["qqbot_group_openid"] = raw_event.get("group_openid", "")
+            base_event["qqbot_member_openid"] = author.get("member_openid", "")
+        elif raw_type in ("AT_MESSAGE_CREATE", "MESSAGE_CREATE"):
+            author = raw_event.get("author", {})
+            base_event["user_id"] = str(author.get("user_openid", author.get("id", "")))
+            base_event["user_nickname"] = author.get("nick", author.get("username", ""))
+            base_event["channel_id"] = raw_event.get("channel_id", "")
+            base_event["group_id"] = raw_event.get("guild_id", "")
+            base_event["message_id"] = raw_event.get("id", "")
+        elif raw_type == "DIRECT_MESSAGE_CREATE":
+            author = raw_event.get("author", {})
+            base_event["user_id"] = str(author.get("user_openid", author.get("id", "")))
+            base_event["user_nickname"] = author.get("nick", author.get("username", ""))
+            base_event["message_id"] = raw_event.get("id", "")
+            base_event["qqbot_guild_id"] = raw_event.get("guild_id", "")
+
+        content = raw_event.get("content", "")
+        attachments = raw_event.get("attachments", [])
+        message_segments = []
+
+        if raw_event.get("event_id"):
+            pass
+
+        if "reply_token" in raw_event and raw_type in ("C2C_MESSAGE_CREATE", "GROUP_AT_MESSAGE_CREATE"):
+            pass
+
+        for mention in raw_event.get("mentions", []):
+            message_segments.append({
+                "type": "mention",
+                "data": {
+                    "user_id": str(mention.get("id", "")),
+                    "user_name": mention.get("nick", mention.get("username", "")),
+                },
+            })
+
+        if content:
+            message_segments.append({"type": "text", "data": {"text": content.strip()}})
+
+        for attachment in attachments:
+            content_type = attachment.get("content_type", "")
+            url = attachment.get("url", "")
+            if content_type.startswith("image"):
+                message_segments.append({
+                    "type": "image",
+                    "data": {"url": url, "qqbot_attachment": attachment},
+                })
+            elif content_type.startswith("video"):
+                message_segments.append({
+                    "type": "video",
+                    "data": {"url": url, "qqbot_attachment": attachment},
+                })
+            elif content_type.startswith("audio"):
+                message_segments.append({
+                    "type": "voice",
+                    "data": {"url": url, "qqbot_attachment": attachment},
+                })
+            else:
+                message_segments.append({
+                    "type": "file",
+                    "data": {"url": url, "qqbot_attachment": attachment},
+                })
+
+        base_event["message"] = message_segments
+        base_event["alt_message"] = self._generate_alt_message(message_segments)
+
+        if raw_type == "C2C_MESSAGE_CREATE":
+            base_event["qqbot_event_id"] = raw_event.get("id", "")
+            base_event["qqbot_reply_token"] = raw_event.get("reply_token", "")
+        elif raw_type == "GROUP_AT_MESSAGE_CREATE":
+            base_event["qqbot_event_id"] = raw_event.get("id", "")
+            base_event["qqbot_reply_token"] = raw_event.get("reply_token", "")
+
+        return base_event
+
+    def _handle_notice(self, raw_event: Dict, base_event: Dict, raw_type: str) -> Dict:
+        if raw_type == "GUILD_MEMBER_ADD":
+            base_event["user_id"] = str(raw_event.get("user", {}).get("id", ""))
+            base_event["user_nickname"] = raw_event.get("user", {}).get("nick", "")
+            base_event["group_id"] = raw_event.get("guild_id", "")
+            base_event["operator_id"] = ""
+        elif raw_type in ("GUILD_MEMBER_UPDATE", "GUILD_MEMBER_REMOVE"):
+            base_event["user_id"] = str(raw_event.get("user", {}).get("id", ""))
+            base_event["user_nickname"] = raw_event.get("user", {}).get("nick", "")
+            base_event["group_id"] = raw_event.get("guild_id", "")
+            base_event["operator_id"] = str(raw_event.get("op_user_id", ""))
+        elif raw_type in ("GROUP_ADD_ROBOT", "GROUP_DEL_ROBOT", "GROUP_MSG_REJECT", "GROUP_MSG_RECEIVE"):
+            base_event["group_id"] = raw_event.get("group_openid", "")
+            base_event["operator_id"] = raw_event.get("op_member_openid", "")
+        elif raw_type in ("FRIEND_ADD", "FRIEND_DEL"):
+            base_event["user_id"] = raw_event.get("openid", "")
+            base_event["user_nickname"] = ""
+        elif raw_type in ("C2C_MSG_REJECT", "C2C_MSG_RECEIVE"):
+            base_event["user_id"] = raw_event.get("openid", "")
+        elif raw_type == "INTERACTION_CREATE":
+            base_event["qqbot_interaction_id"] = raw_event.get("id", "")
+            base_event["qqbot_interaction_type"] = raw_event.get("type", "")
+            base_event["qqbot_interaction_data"] = raw_event.get("data", {})
+        elif raw_type in ("MESSAGE_AUDIT_PASS", "MESSAGE_AUDIT_REJECT"):
+            base_event["qqbot_audit_id"] = raw_event.get("audit_id", "")
+            base_event["qqbot_message_id"] = raw_event.get("message_id", "")
+            if raw_type == "MESSAGE_AUDIT_REJECT":
+                base_event["qqbot_audit_reject_reason"] = raw_event.get("audit_reject_reason", "")
+        elif raw_type in ("CHANNEL_CREATE", "CHANNEL_UPDATE", "CHANNEL_DELETE"):
+            base_event["channel_id"] = raw_event.get("id", "")
+            base_event["group_id"] = raw_event.get("guild_id", "")
+            base_event["qqbot_channel_name"] = raw_event.get("name", "")
+        elif raw_type in ("GUILD_CREATE", "GUILD_UPDATE", "GUILD_DELETE"):
+            base_event["group_id"] = raw_event.get("id", "")
+            base_event["qqbot_guild_name"] = raw_event.get("name", "")
+        elif raw_type == "qqbot_message_delete":
+            base_event["message_id"] = raw_event.get("id", "")
+            base_event["operator_id"] = raw_event.get("op_user_id", "")
+
+        return base_event
+
+    def _create_unknown_event(self, raw_event: Dict, event_id: str, raw_type: str) -> Dict:
+        return {
+            "id": str(event_id),
+            "time": int(time.time()),
+            "type": "unknown",
+            "detail_type": "unknown",
+            "platform": "qqbot",
+            "self": {"platform": "qqbot", "user_id": self._bot_id_getter() if self._bot_id_getter else ""},
+            "qqbot_raw": raw_event,
+            "qqbot_raw_type": raw_type,
+            "warning": f"Unsupported event type: {raw_type}",
+            "alt_message": "This event type is not supported by this system.",
+        }
+
+    def _parse_timestamp(self, timestamp) -> int:
+        if isinstance(timestamp, (int, float)):
+            ts = int(timestamp)
+            return ts // 1000 if ts > 10**12 else ts
+        if isinstance(timestamp, str):
+            try:
+                ts = int(timestamp)
+                return ts // 1000 if ts > 10**12 else ts
+            except ValueError:
+                pass
+            try:
+                dt = datetime.fromisoformat(timestamp)
+                return int(dt.timestamp())
+            except (ValueError, TypeError):
+                pass
+        return int(time.time())
+
+    def _generate_alt_message(self, segments: List[Dict]) -> str:
+        parts = []
+        for seg in segments:
+            seg_type = seg["type"]
+            data = seg.get("data", {})
+            if seg_type == "text":
+                parts.append(data.get("text", ""))
+            elif seg_type == "image":
+                parts.append("[图片]")
+            elif seg_type == "video":
+                parts.append("[视频]")
+            elif seg_type == "voice":
+                parts.append("[语音]")
+            elif seg_type == "file":
+                parts.append("[文件]")
+            elif seg_type in ("at", "mention"):
+                parts.append(f"@{data.get('user_name', data.get('user_id', ''))}")
+            elif seg_type == "reply":
+                parts.append("[回复]")
+        return " ".join(parts).strip()

QQBotAdapter/Core.py

@@ -0,0 +1,413 @@
+import asyncio
+import aiohttp
+import json
+import uuid
+from typing import Dict, List, Any, Optional
+from ErisPulse import sdk
+from ErisPulse.Core import router
+from .Converter import QQBotConverter
+from .WebSocket import QQBotWebSocket
+
+
+class QQBotAdapter(sdk.BaseAdapter):
+    class Send(sdk.BaseAdapter.Send):
+        def __init__(self, adapter, target_type=None, target_id=None, account_id=None):
+            super().__init__(adapter, target_type, target_id, account_id)
+            self._at_user_ids = []
+            self._at_all = False
+            self._reply_message_id = None
+            self._keyboard = None
+
+        def Text(self, text: str):
+            return self.Raw_ob12([{"type": "text", "data": {"text": text}}])
+
+        def Image(self, file: bytes | str):
+            return self.Raw_ob12([{"type": "image", "data": {"file": file}}])
+
+        def Markdown(self, content: str):
+            return self.Raw_ob12([{"type": "markdown", "data": {"content": content}}])
+
+        def Ark(self, template_id: int, kv: list):
+            return self.Raw_ob12([{"type": "ark", "data": {"template_id": template_id, "kv": kv}}])
+
+        def Embed(self, embed_data: dict):
+            return self.Raw_ob12([{"type": "embed", "data": embed_data}])
+
+        def Keyboard(self, keyboard: dict):
+            self._keyboard = keyboard
+            return self
+
+        def Reply(self, message_id: str) -> "Send":
+            self._reply_message_id = message_id
+            return self
+
+        def At(self, user_id: str) -> "Send":
+            self._at_user_ids.append(user_id)
+            return self
+
+        def AtAll(self) -> "Send":
+            self._at_all = True
+            return self
+
+        def _reset_modifiers(self):
+            self._at_user_ids = []
+            self._at_all = False
+            self._reply_message_id = None
+            self._keyboard = None
+
+        def Raw_ob12(self, message: List[Dict], **kwargs):
+            return asyncio.create_task(self._do_send_raw_ob12(message, **kwargs))
+
+        async def _do_send_raw_ob12(self, message: List[Dict], **kwargs):
+            text_parts = []
+            media_info = None
+            msg_type = 0
+            markdown_data = None
+            ark_data = None
+            embed_data = None
+
+            for segment in message:
+                seg_type = segment.get("type")
+                data = segment.get("data", {})
+
+                if seg_type == "text":
+                    text_parts.append(data.get("text", ""))
+                elif seg_type == "image":
+                    file = data.get("file", data.get("url", ""))
+                    if isinstance(file, bytes):
+                        media_info = await self._adapter._upload_media(file, self._target_type, self._target_id, 1)
+                    elif file:
+                        media_info = await self._adapter._upload_media(file, self._target_type, self._target_id, 1)
+                    if media_info:
+                        msg_type = 7
+                elif seg_type == "voice":
+                    file = data.get("file", data.get("url", ""))
+                    if isinstance(file, (bytes, str)) and file:
+                        media_info = await self._adapter._upload_media(file, self._target_type, self._target_id, 3)
+                    if media_info:
+                        msg_type = 7
+                elif seg_type == "video":
+                    file = data.get("file", data.get("url", ""))
+                    if isinstance(file, (bytes, str)) and file:
+                        media_info = await self._adapter._upload_media(file, self._target_type, self._target_id, 2)
+                    if media_info:
+                        msg_type = 7
+                elif seg_type == "file":
+                    file = data.get("file", data.get("url", ""))
+                    if isinstance(file, (bytes, str)) and file:
+                        media_info = await self._adapter._upload_media(file, self._target_type, self._target_id, 4)
+                    if media_info:
+                        msg_type = 7
+                elif seg_type == "markdown":
+                    msg_type = 2
+                    markdown_data = data
+                elif seg_type == "ark":
+                    msg_type = 3
+                    ark_data = data
+                elif seg_type == "embed":
+                    msg_type = 4
+                    embed_data = data
+
+            for uid in self._at_user_ids:
+                text_parts.append(f"<@{uid}>")
+            if self._at_all:
+                text_parts.insert(0, "@所有人")
+
+            content = "".join(text_parts) or " "
+            msg_id = self._reply_message_id or kwargs.get("msg_id", "")
+            if not msg_id and self._target_type and self._target_id:
+                msg_id = self._adapter._pending_msg_ids.get(f"{self._target_type}:{self._target_id}", "")
+            params = {"msg_type": msg_type, "content": content if msg_type in (0, 7) else "", "msg_id": msg_id}
+
+            if msg_type == 2 and markdown_data:
+                params["markdown"] = {"content": markdown_data.get("content", "")}
+            elif msg_type == 3 and ark_data:
+                params["ark"] = {"template_id": ark_data.get("template_id", 0), "kv": ark_data.get("kv", [])}
+            elif msg_type == 4 and embed_data:
+                params["embed"] = embed_data
+            elif msg_type == 7 and media_info:
+                params["media"] = {"file_info": media_info}
+
+            if self._keyboard:
+                params["keyboard"] = self._keyboard
+
+            endpoint = self._get_send_endpoint()
+            if not endpoint:
+                self._reset_modifiers()
+                return {
+                    "status": "failed",
+                    "retcode": 10003,
+                    "data": None,
+                    "message_id": "",
+                    "message": "无法确定发送目标",
+                    "qqbot_raw": None,
+                }
+
+            self._reset_modifiers()
+            return await self._adapter.call_api(endpoint=endpoint, **params)
+
+        def _get_send_endpoint(self) -> Optional[str]:
+            if self._target_type == "user":
+                return f"/v2/users/{self._target_id}/messages"
+            elif self._target_type == "group":
+                return f"/v2/groups/{self._target_id}/messages"
+            elif self._target_type == "channel":
+                return f"/channels/{self._target_id}/messages"
+            elif self._target_type == "dms":
+                return f"/dms/{self._target_id}/messages"
+            return None
+
+    def __init__(self, sdk):
+        super().__init__()
+        self.sdk = sdk
+        self.logger = sdk.logger
+        self.config = self._load_config()
+        self.appid = self.config.get("appid", "")
+        self.secret = self.config.get("secret", "")
+        self._access_token = None
+        self._token_expires = 0
+        self.bot_id = ""
+        self.session: Optional[aiohttp.ClientSession] = None
+        self.ws_client: Optional[QQBotWebSocket] = None
+        self._heartbeat_meta_task: Optional[asyncio.Task] = None
+        self._pending_msg_ids: Dict[str, str] = {}
+
+        converter = QQBotConverter(bot_id_getter=lambda: self.bot_id)
+        self.convert = converter.convert
+
+    def _load_config(self):
+        config = self.sdk.config.getConfig("QQBot_Adapter")
+        if not config:
+            default_config = {
+                "appid": "YOUR_APPID",
+                "secret": "YOUR_CLIENT_SECRET",
+                "sandbox": False,
+                "intents": [1, 30, 25],
+            }
+            try:
+                self.sdk.config.setConfig("QQBot_Adapter", default_config)
+                self.logger.warning("QQBot适配器配置不存在，已自动创建默认配置")
+            except Exception as e:
+                self.logger.error(f"保存默认配置失败: {e}")
+            return default_config
+        return config
+
+    def _get_base_url(self) -> str:
+        if self.config.get("sandbox", False):
+            return "https://sandbox.api.sgroup.qq.com"
+        return "https://api.sgroup.qq.com"
+
+    def _get_intents_value(self) -> int:
+        intents = self.config.get("intents", [1, 30, 25])
+        value = 0
+        for intent in intents:
+            value |= (1 << intent)
+        return value
+
+    async def _ensure_token(self) -> str:
+        import time as _time
+        if self._access_token and _time.time() < self._token_expires - 120:
+            return self._access_token
+        await self._refresh_token()
+        return self._access_token
+
+    async def _refresh_token(self):
+        import time as _time
+        url = "https://bots.qq.com/app/getAppAccessToken"
+        payload = {"appId": self.appid, "clientSecret": self.secret}
+        try:
+            async with self.session.post(url, json=payload) as resp:
+                data = await resp.json()
+                self._access_token = data.get("access_token", "")
+                expires_in = int(data.get("expires_in", 7200))
+                self._token_expires = _time.time() + expires_in
+                self.logger.debug("Access Token 已获取/刷新")
+        except Exception as e:
+            self.logger.error(f"获取 Access Token 失败: {e}")
+            raise
+
+    async def _upload_media(self, file, target_type: str, target_id: str, file_type: int) -> Optional[str]:
+        url = f"{self._get_base_url()}"
+        if target_type == "user":
+            url += f"/v2/users/{target_id}/files"
+        elif target_type == "group":
+            url += f"/v2/groups/{target_id}/files"
+        else:
+            return None
+
+        token = await self._ensure_token()
+        headers = {"Authorization": f"QQBot {token}", "Content-Type": "application/json"}
+
+        payload = {"file_type": file_type, "srv_send_msg": False}
+
+        if isinstance(file, str) and file.startswith(("http://", "https://")):
+            payload["url"] = file
+        elif isinstance(file, bytes):
+            import base64
+            payload["file_data"] = base64.b64encode(file).decode("utf-8")
+        elif isinstance(file, str):
+            try:
+                import os
+                if os.path.isfile(file):
+                    with open(file, "rb") as f:
+                        file_bytes = f.read()
+                    import base64
+                    payload["file_data"] = base64.b64encode(file_bytes).decode("utf-8")
+                else:
+                    self.logger.error(f"文件不存在: {file}")
+                    return None
+            except Exception as e:
+                self.logger.error(f"读取本地文件失败: {e}")
+                return None
+
+        try:
+            async with self.session.post(url, json=payload, headers=headers) as resp:
+                data = await resp.json()
+                self.logger.debug(f"上传媒体响应: {data}")
+                file_info = data.get("file_info", "")
+                if not file_info:
+                    self.logger.error(f"上传媒体失败: {data}")
+                    return None
+                return file_info
+        except Exception as e:
+            self.logger.error(f"上传媒体异常: {e}")
+            return None
+
+    async def call_api(self, endpoint: str, **params):
+        token = await self._ensure_token()
+        url = f"{self._get_base_url()}{endpoint}"
+        headers = {"Authorization": f"QQBot {token}", "Content-Type": "application/json"}
+
+        try:
+            async with self.session.post(url, json=params, headers=headers) as resp:
+                raw_response = await resp.json()
+
+                self.logger.debug(f"QQBot API 请求: {url}")
+                self.logger.debug(f"QQBot API 响应: {raw_response}")
+
+                if not isinstance(raw_response, dict):
+                    return {
+                        "status": "failed",
+                        "retcode": 34000,
+                        "data": None,
+                        "message_id": "",
+                        "message": f"API 返回了意外格式: {type(raw_response)}",
+                        "qqbot_raw": raw_response,
+                    }
+
+                code = raw_response.get("code", 0)
+                success = 200 <= resp.status < 300 and code == 0
+                msg_id = raw_response.get("id", raw_response.get("data", {}).get("id", ""))
+
+                return {
+                    "status": "ok" if success else "failed",
+                    "retcode": 0 if success else code or 34000,
+                    "data": raw_response.get("data", raw_response),
+                    "message_id": str(msg_id) if msg_id else "",
+                    "message": "" if success else raw_response.get("message", "Unknown QQBot API error"),
+                    "qqbot_raw": raw_response,
+                }
+
+        except asyncio.TimeoutError:
+            self.logger.error(f"QQBot API 请求超时: {endpoint}")
+            return {
+                "status": "failed",
+                "retcode": 32000,
+                "data": None,
+                "message_id": "",
+                "message": "请求超时",
+                "qqbot_raw": None,
+            }
+        except Exception as e:
+            self.logger.error(f"调用 QQBot API 失败: {e}")
+            return {
+                "status": "failed",
+                "retcode": 33000,
+                "data": None,
+                "message_id": "",
+                "message": f"API调用失败: {str(e)}",
+                "qqbot_raw": None,
+            }
+
+    def _store_event_msg_id(self, event: Dict):
+        if event.get("type") != "message":
+            return
+        detail_type = event.get("detail_type", "")
+        msg_id = event.get("message_id", "")
+        if not msg_id:
+            return
+        if detail_type == "group" and "group_id" in event:
+            self._pending_msg_ids[f"group:{event['group_id']}"] = msg_id
+        elif detail_type == "private":
+            user_id = event.get("user_id", "")
+            if user_id:
+                self._pending_msg_ids[f"user:{user_id}"] = msg_id
+        elif detail_type == "channel":
+            channel_id = event.get("channel_id", "")
+            if channel_id:
+                self._pending_msg_ids[f"channel:{channel_id}"] = msg_id
+
+    async def _on_connect(self):
+        await self.sdk.adapter.emit({
+            "type": "meta",
+            "detail_type": "connect",
+            "platform": "qqbot",
+            "self": {"platform": "qqbot", "user_id": self.bot_id},
+        })
+
+        self._heartbeat_meta_task = asyncio.create_task(self._heartbeat_meta_loop())
+
+    async def _heartbeat_meta_loop(self):
+        try:
+            while True:
+                await asyncio.sleep(30)
+                await self.sdk.adapter.emit({
+                    "type": "meta",
+                    "detail_type": "heartbeat",
+                    "platform": "qqbot",
+                    "self": {"platform": "qqbot", "user_id": self.bot_id},
+                })
+        except asyncio.CancelledError:
+            pass
+
+    async def start(self):
+        self.session = aiohttp.ClientSession()
+
+        try:
+            await self._ensure_token()
+        except Exception as e:
+            self.logger.error(f"初始化 Token 失败: {e}")
+            if self.session:
+                await self.session.close()
+            raise
+
+        self.ws_client = QQBotWebSocket(self)
+        await self.ws_client.connect()
+        await self.ws_client.start_token_refresh()
+        self.logger.info("QQBot 适配器已启动")
+
+    async def shutdown(self):
+        if self.bot_id:
+            await self.sdk.adapter.emit({
+                "type": "meta",
+                "detail_type": "disconnect",
+                "platform": "qqbot",
+                "self": {"platform": "qqbot", "user_id": self.bot_id},
+            })
+
+        if self._heartbeat_meta_task:
+            self._heartbeat_meta_task.cancel()
+            try:
+                await self._heartbeat_meta_task
+            except asyncio.CancelledError:
+                pass
+            self._heartbeat_meta_task = None
+
+        if self.ws_client:
+            await self.ws_client.close()
+            self.ws_client = None
+
+        if self.session:
+            await self.session.close()
+            self.session = None
+        self.logger.info("QQBot 适配器已关闭")

QQBotAdapter/WebSocket.py

@@ -0,0 +1,245 @@
+import asyncio
+import json
+import time
+import aiohttp
+from typing import Optional
+
+
+class QQBotWebSocket:
+    OP_HELLO = 10
+    OP_IDENTIFY = 2
+    OP_HEARTBEAT = 1
+    OP_HEARTBEAT_ACK = 11
+    OP_DISPATCH = 0
+    OP_RESUME = 6
+    OP_RECONNECT = 7
+    OP_INVALID_SESSION = 9
+
+    def __init__(self, adapter):
+        self.adapter = adapter
+        self.session: Optional[aiohttp.ClientSession] = None
+        self.ws: Optional[aiohttp.ClientWebSocketResponse] = None
+        self.heartbeat_interval = 45000
+        self.heartbeat_task: Optional[asyncio.Task] = None
+        self.listen_task: Optional[asyncio.Task] = None
+        self.seq: Optional[int] = None
+        self.session_id: Optional[str] = None
+        self._connected = False
+        self._token_refresh_task: Optional[asyncio.Task] = None
+        self._reconnect_count = 0
+        self._max_reconnect = 50
+
+    async def connect(self):
+        self.session = aiohttp.ClientSession()
+        gateway_url = self.adapter.config.get("gateway_url", "wss://api.sgroup.qq.com/websocket/")
+        await self._connect(gateway_url)
+
+    async def _connect(self, url: str):
+        try:
+            self.ws = await self.session.ws_connect(url)
+            self.adapter.logger.info("WebSocket 已连接到 QQBot 网关")
+            self._connected = True
+
+            msg = await self.ws.receive_json()
+            if msg.get("op") == self.OP_HELLO:
+                data = msg.get("d", {})
+                self.heartbeat_interval = data.get("heartbeat_interval", 45000)
+
+                if self.session_id and self.seq is not None:
+                    await self._resume()
+                else:
+                    await self._identify()
+
+                self.heartbeat_task = asyncio.create_task(self._heartbeat_loop())
+                self.listen_task = asyncio.create_task(self._listen())
+
+                self._reconnect_count = 0
+            else:
+                self.adapter.logger.error(f"未收到 Hello 消息: {msg}")
+
+        except Exception as e:
+            self.adapter.logger.error(f"WebSocket 连接失败: {e}")
+            await self._reconnect()
+
+    async def _identify(self):
+        token = await self.adapter._ensure_token()
+        payload = {
+            "op": self.OP_IDENTIFY,
+            "d": {
+                "token": f"QQBot {token}",
+                "intents": self.adapter._get_intents_value(),
+                "shard": [0, 1],
+            },
+        }
+        await self.ws.send_json(payload)
+        self.adapter.logger.info("已发送 Identify")
+
+    async def _resume(self):
+        token = await self.adapter._ensure_token()
+        payload = {
+            "op": self.OP_RESUME,
+            "d": {
+                "token": f"QQBot {token}",
+                "session_id": self.session_id,
+                "seq": self.seq,
+            },
+        }
+        await self.ws.send_json(payload)
+        self.adapter.logger.info("已发送 Resume")
+
+    async def _heartbeat_loop(self):
+        try:
+            while self._connected and self.ws and not self.ws.closed:
+                heartbeat_payload = {
+                    "op": self.OP_HEARTBEAT,
+                    "d": self.seq,
+                }
+                try:
+                    await self.ws.send_json(heartbeat_payload)
+                except Exception as e:
+                    self.adapter.logger.error(f"发送心跳失败: {e}")
+                    break
+                await asyncio.sleep(self.heartbeat_interval / 1000)
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            self.adapter.logger.error(f"心跳循环异常: {e}")
+            await self._reconnect()
+
+    async def _listen(self):
+        try:
+            async for msg in self.ws:
+                if msg.type == aiohttp.WSMsgType.TEXT:
+                    data = json.loads(msg.data)
+                    await self._handle_message(data)
+                elif msg.type in (aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.ERROR):
+                    self.adapter.logger.warning(f"WebSocket 关闭: {msg.type}")
+                    break
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            self.adapter.logger.error(f"监听异常: {e}")
+        finally:
+            self._connected = False
+            if not self.listen_task or not self.listen_task.cancelled():
+                await self._reconnect()
+
+    async def _handle_message(self, data: dict):
+        op = data.get("op")
+        t = data.get("t")
+        d = data.get("d")
+        s = data.get("s")
+
+        if s is not None:
+            self.seq = s
+
+        if op == self.OP_DISPATCH:
+            if t == "READY":
+                self.session_id = d.get("session_id") if d else None
+                user = d.get("user", {}) if d else {}
+                self.adapter.bot_id = str(user.get("id", ""))
+                self.adapter.logger.info(f"QQBot 就绪, bot_id: {self.adapter.bot_id}")
+                await self.adapter._on_connect()
+            elif t == "RESUMED":
+                self.adapter.logger.info("QQBot 会话已恢复")
+            else:
+                if d:
+                    onebot_event = self.adapter.convert(d, t or "")
+                    if onebot_event:
+                        self.adapter._store_event_msg_id(onebot_event)
+                        from ErisPulse.Core import logger
+                        logger.debug(f"收到事件: {onebot_event}")
+                        await self.adapter.sdk.adapter.emit(onebot_event)
+
+        elif op == self.OP_HEARTBEAT_ACK:
+            pass
+
+        elif op == self.OP_RECONNECT:
+            self.adapter.logger.warning("收到 Reconnect 指令，重新连接")
+            await self._reconnect()
+
+        elif op == self.OP_INVALID_SESSION:
+            self.adapter.logger.warning("会话无效，重新 Identify")
+            self.session_id = None
+            self.seq = None
+            await self._reconnect()
+
+        elif op == self.OP_HELLO:
+            data_inner = d if d else {}
+            self.heartbeat_interval = data_inner.get("heartbeat_interval", 45000)
+
+    async def _reconnect(self):
+        if self.heartbeat_task:
+            self.heartbeat_task.cancel()
+            try:
+                await self.heartbeat_task
+            except asyncio.CancelledError:
+                pass
+            self.heartbeat_task = None
+
+        self._reconnect_count += 1
+        if self._reconnect_count > self._max_reconnect:
+            self.adapter.logger.error("已达到最大重连次数，停止重连")
+            return
+
+        wait_time = min(5 * (2 ** min(self._reconnect_count, 6)), 300)
+        self.adapter.logger.warning(f"{wait_time}秒后尝试第 {self._reconnect_count} 次重连")
+        await asyncio.sleep(wait_time)
+
+        try:
+            if self.ws and not self.ws.closed:
+                await self.ws.close()
+        except Exception:
+            pass
+
+        gateway_url = self.adapter.config.get("gateway_url", "wss://api.sgroup.qq.com/websocket/")
+        await self._connect(gateway_url)
+
+    async def start_token_refresh(self):
+        self._token_refresh_task = asyncio.create_task(self._token_refresh_loop())
+
+    async def _token_refresh_loop(self):
+        try:
+            while True:
+                await asyncio.sleep(7200 - 120)
+                await self.adapter._refresh_token()
+                self.adapter.logger.info("Access Token 已刷新")
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            self.adapter.logger.error(f"Token 刷新异常: {e}")
+
+    async def close(self):
+        self._connected = False
+
+        if self._token_refresh_task:
+            self._token_refresh_task.cancel()
+            try:
+                await self._token_refresh_task
+            except asyncio.CancelledError:
+                pass
+            self._token_refresh_task = None
+
+        if self.heartbeat_task:
+            self.heartbeat_task.cancel()
+            try:
+                await self.heartbeat_task
+            except asyncio.CancelledError:
+                pass
+            self.heartbeat_task = None
+
+        if self.listen_task:
+            self.listen_task.cancel()
+            try:
+                await self.listen_task
+            except asyncio.CancelledError:
+                pass
+            self.listen_task = None
+
+        if self.ws and not self.ws.closed:
+            await self.ws.close()
+        if self.session:
+            await self.session.close()
+            self.session = None
+
+        self.adapter.logger.info("WebSocket 连接已关闭")

QQBotAdapter/__init__.py

@@ -0,0 +1 @@
+from .Core import QQBotAdapter

erispulse_qqbotadapter-1.0.0.dist-info/METADATA

@@ -0,0 +1,259 @@
+Metadata-Version: 2.4
+Name: ErisPulse-QQBotAdapter
+Version: 1.0.0
+Summary: ErisPulse的QQ官方机器人适配模块
+Author-email: wsu2059 <wsu2059@qq.com>
+Project-URL: homepage, https://github.com/ErisPulse/ErisPulse-QQBotAdapter
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.8.0
+
+# QQBotAdapter 模块文档
+
+## 简介
+QQBotAdapter 是基于 [ErisPulse](https://github.com/ErisPulse/ErisPulse/) 架构的QQ官方机器人协议适配器，通过WebSocket长连接接收事件，整合了群聊、私聊、频道等多种场景的功能模块，提供统一的事件处理和消息操作接口。
+
+## 使用示例
+
+### 平台原生事件映射关系
+| 官方事件命名 | Adapter事件命名 |
+|--------------|----------------|
+| C2C_MESSAGE_CREATE | private_message |
+| GROUP_AT_MESSAGE_CREATE | group_message |
+| AT_MESSAGE_CREATE | channel_message |
+| MESSAGE_CREATE | channel_message |
+| DIRECT_MESSAGE_CREATE | direct_message |
+| FRIEND_ADD | friend_add |
+| FRIEND_DEL | friend_del |
+| GROUP_ADD_ROBOT | group_add |
+| GROUP_DEL_ROBOT | group_del |
+| GROUP_MSG_REJECT | group_block |
+| GROUP_MSG_RECEIVE | group_allow |
+| C2C_MSG_REJECT | private_block |
+| C2C_MSG_RECEIVE | private_allow |
+| GUILD_MEMBER_ADD | guild_member_add |
+| GUILD_MEMBER_UPDATE | guild_member_update |
+| GUILD_MEMBER_REMOVE | guild_member_remove |
+| INTERACTION_CREATE | interaction |
+| MESSAGE_AUDIT_PASS | audit_pass |
+| MESSAGE_AUDIT_REJECT | audit_reject |
+
+这仅仅在 `sdk.adapter.qqbot.on()` 的时候生效，你完全可以使用标准OneBot12事件（`sdk.adapter.on`）来获取信息。
+
+### OneBot12标准事件类型
+
+QQBot适配器完全兼容 OneBot12 标准事件格式，并提供了一些扩展字段：
+
+| 事件类型 | detail_type | 说明 |
+|----------|-------------|------|
+| 消息事件（私聊） | private | 用户发送的私聊消息 |
+| 消息事件（群聊） | group | 群内用户@机器人的消息 |
+| 消息事件（频道） | channel | 频道内消息 |
+| 好友增加 | friend_add | 用户添加机器人为好友 |
+| 好友删除 | friend_del | 用户删除机器人好友 |
+| 群增加 | group_increase | 群添加机器人 |
+| 群减少 | group_decrease | 群移除机器人 |
+| 群消息屏蔽 | group_block | 群拒绝机器人消息 |
+| 群消息允许 | group_allow | 群允许机器人消息 |
+| 私聊屏蔽 | private_block | 用户拒绝机器人私聊 |
+| 私聊允许 | private_allow | 用户允许机器人私聊 |
+| 群成员增加 | group_member_increase | 频道成员加入 |
+| 群成员更新 | group_member_update | 频道成员更新 |
+| 群成员减少 | group_member_decrease | 频道成员退出 |
+| 频道服务器创建 | guild_create | 频道服务器创建 |
+| 频道服务器更新 | guild_update | 频道服务器更新 |
+| 频道服务器删除 | guild_delete | 频道服务器删除 |
+| 子频道创建 | channel_create | 子频道创建 |
+| 子频道更新 | channel_update | 子频道更新 |
+| 子频道删除 | channel_delete | 子频道删除 |
+| QQBot交互事件 | qqbot_interaction | 按钮点击等交互 |
+| QQBot审核通过 | qqbot_audit_pass | 消息审核通过 |
+| QQBot审核拒绝 | qqbot_audit_reject | 消息审核拒绝 |
+| QQBot表情回应添加 | qqbot_reaction_add | 消息表情回应添加 |
+| QQBot表情回应移除 | qqbot_reaction_remove | 消息表情回应移除 |
+| QQBot音频开始 | qqbot_audio_start | 音频开始播放 |
+| QQBot音频结束 | qqbot_audio_finish | 音频播放结束 |
+| QQBot消息删除 | qqbot_message_delete | 消息被删除 |
+
+---
+
+## 消息发送示例
+
+```python
+from ErisPulse import sdk
+qqbot = sdk.adapter.get("qqbot")
+
+# 发送文本消息
+await qqbot.Send.To("user", user_openid).Text("Hello World!")
+
+# 发送带@的消息
+await qqbot.Send.To("group", group_openid).At("member_openid").Text("@你")
+
+# 发送带@所有人的消息
+await qqbot.Send.To("group", group_openid).AtAll().Text("公告通知")
+
+# 发送回复消息
+await qqbot.Send.To("group", group_openid).Reply("msg_id").Text("回复内容")
+
+# 发送图片（URL）
+await qqbot.Send.To("group", group_openid).Image("https://example.com/image.png")
+
+# 发送图片（二进制数据）
+with open("image.png", "rb") as f:
+    image_data = f.read()
+await qqbot.Send.To("user", user_openid).Image(image_data)
+
+# 发送 Markdown 格式消息
+await qqbot.Send.To("group", group_openid).Markdown("# 标题\n- 列表项")
+
+# 发送 Ark 模板消息
+await qqbot.Send.To("user", user_openid).Ark(template_id=1, kv=[{"key": "title", "value": "标题"}])
+
+# 发送 Embed 消息
+await qqbot.Send.To("group", group_openid).Embed({"title": "标题", "content": "内容"})
+
+# 发送带键盘的消息
+keyboard = {
+    "content": [
+        [
+            {"label": "确认", "type": 2, "data": "confirm"},
+            {"label": "取消", "type": 2, "data": "cancel"}
+        ]
+    ]
+}
+await qqbot.Send.To("group", group_openid).Keyboard(keyboard).Text("请选择")
+
+# 组合使用：回复 + @ + 键盘
+await qqbot.Send.To("group", group_openid).Reply("msg_id").At("member_openid").Keyboard(keyboard).Text("复合消息")
+
+# 使用 Raw_ob12 发送 OneBot12 格式消息
+message = [
+    {"type": "text", "data": {"text": "第一行"}},
+    {"type": "image", "data": {"file": "https://example.com/img.jpg"}},
+    {"type": "text", "data": {"text": "第二行"}}
+]
+await qqbot.Send.To("group", group_openid).Raw_ob12(message)
+```
+
+---
+
+### 配置说明
+
+首次运行会自动生成默认配置。
+
+```toml
+# config.toml
+[QQBot_Adapter]
+appid = "YOUR_APPID"                                    # QQ机器人应用ID（必填）
+secret = "YOUR_CLIENT_SECRET"                            # QQ机器人客户端密钥（必填）
+sandbox = false                                          # 是否使用沙盒环境（可选，默认为false）
+intents = [1, 30, 25]                                    # 订阅的事件 intents 位（可选）
+gateway_url = "wss://api.sgroup.qq.com/websocket/"       # WebSocket网关地址（可选）
+```
+
+**配置项说明：**
+- `appid`：QQ机器人的应用ID（必填），从QQ开放平台获取
+- `secret`：QQ机器人的客户端密钥（必填），从QQ开放平台获取
+- `sandbox`：是否使用沙盒环境，沙盒环境API地址为 `https://sandbox.api.sgroup.qq.com`
+- `intents`：事件订阅 intents 列表，常用值：
+  - `1`：频道相关事件
+  - `25`：频道消息事件
+  - `30`：群@消息事件
+- `gateway_url`：WebSocket 网关地址，默认为 `wss://api.sgroup.qq.com/websocket/`
+
+---
+
+## QQBot平台特有功能
+
+请参考 [QQBot平台特性文档](platform-features.md) 了解QQBot平台的特有功能，包括openid体系、频道系统、消息审核、交互事件、扩展字段说明等内容。
+
+详细的事件转换对照请参考 [转换对照文档](CoverToOnebot12.md)。
+
+## 事件监听示例
+
+### 使用 Event 模块（推荐）
+
+```python
+from ErisPulse.Core.Event import message, notice
+
+@message.on_message()
+async def handle_message(event):
+    if event["platform"] == "qqbot":
+        detail_type = event["detail_type"]
+        if detail_type == "private":
+            # 处理私聊消息
+            pass
+        elif detail_type == "group":
+            # 处理群@消息
+            pass
+        elif detail_type == "channel":
+            # 处理频道消息
+            pass
+
+@notice.on_notice()
+async def handle_notice(event):
+    if event["platform"] == "qqbot":
+        detail_type = event["detail_type"]
+        if detail_type == "qqbot_interaction":
+            # 处理交互事件（按钮点击等）
+            interaction_id = event.get("qqbot_interaction_id", "")
+        elif detail_type == "qqbot_audit_pass":
+            # 消息审核通过
+            pass
+        elif detail_type == "qqbot_audit_reject":
+            # 消息审核拒绝
+            reason = event.get("qqbot_audit_reject_reason", "")
+```
+
+### 使用平台原生事件
+
+```python
+qqbot = sdk.adapter.get("qqbot")
+
+# 使用平台原始事件名
+@qqbot.on("C2C_MESSAGE_CREATE")
+async def handle_private_message(data):
+    pass
+
+@qqbot.on("GROUP_AT_MESSAGE_CREATE")
+async def handle_group_message(data):
+    pass
+
+@qqbot.on("INTERACTION_CREATE")
+async def handle_interaction(data):
+    pass
+```
+
+### 使用 OneBot12 标准事件
+
+```python
+@sdk.adapter.on("message")
+async def handle_message(event):
+    if event["platform"] == "qqbot":
+        bot_id = event["self"]["user_id"]
+        print(f"消息来自Bot: {bot_id}")
+
+@sdk.adapter.on("notice")
+async def handle_notice(event):
+    if event["platform"] == "qqbot":
+        # 处理QQBot通知事件
+        pass
+```
+
+## 注意事项：
+
+1. 确保在调用 `startup()` 前完成所有处理器的注册
+2. QQBot使用 openid 体系而非QQ号，用户和群的标识均为 openid 字符串
+3. 群消息仅在用户@机器人时才会收到（`GROUP_AT_MESSAGE_CREATE`）
+4. 发送的消息可能需要经过审核，通过 `qqbot_audit_pass`/`qqbot_audit_reject` 事件通知结果
+5. 媒体文件（图片、视频等）会上传后通过 file_info 发送，支持URL、本地路径和二进制数据
+6. 程序退出时请调用 `shutdown()` 确保资源释放
+7. access_token 有效期为7200秒，适配器会自动刷新
+
+---
+
+### 参考链接
+
+- [ErisPulse 主库](https://github.com/ErisPulse/ErisPulse/)
+- [QQBot 官方文档](https://bot.q.qq.com/wiki/)
+- [模块开发指南](https://www.erisdev.com/#docs/developer-guide/README.md)

erispulse_qqbotadapter-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+QQBotAdapter/Converter.py,sha256=2CAqEAs_L0uQQrjXU_iDNQEBMFVJ8OrMYhMSogTzkII,12967
+QQBotAdapter/Core.py,sha256=QySpgLZybK4ofwmiPN4JobGWsTxx7IDnlctziCD1eVg,16365
+QQBotAdapter/WebSocket.py,sha256=QRA4Ufxmvct3oPkaz1FebSbij9ADbeXEJr1WMgRf9uQ,8616
+QQBotAdapter/__init__.py,sha256=MfTRRtt40DCHo8gkZXmd7aEID0rf-aEPv9U_cyeAotc,31
+erispulse_qqbotadapter-1.0.0.dist-info/METADATA,sha256=nGgTtEZbDzQuAlrJSgVbwSunXJYQF4LK2VQ5_rLfLN4,9483
+erispulse_qqbotadapter-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+erispulse_qqbotadapter-1.0.0.dist-info/entry_points.txt,sha256=BxZLlrit_qfC5CQpG8oF3BtwOjyrsL2UZCz4XpKFLFg,85
+erispulse_qqbotadapter-1.0.0.dist-info/top_level.txt,sha256=7HVuc1difQDsRMt0gftUVO2lI5q1Cthpz1yCByikwGk,13
+erispulse_qqbotadapter-1.0.0.dist-info/RECORD,,

erispulse_qqbotadapter-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

erispulse_qqbotadapter-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[erispulse.adapter]
+qq = QQBotAdapter:QQBotAdapter
+qqbot = QQBotAdapter:QQBotAdapter

erispulse_qqbotadapter-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+QQBotAdapter