ErisPulse-MatrixAdapter 1.0.0__py3-none-any.whl

MatrixAdapter/Converter.py

@@ -0,0 +1,284 @@
+import time
+import uuid
+from typing import Dict, Optional, List
+
+
+class MatrixConverter:
+    def __init__(self, bot_user_id: str = ""):
+        self.bot_user_id = bot_user_id
+        self._dm_rooms: Dict[str, str] = {}
+
+    def set_dm_rooms(self, dm_rooms: Dict[str, str]):
+        self._dm_rooms = dm_rooms
+
+    def convert(self, raw_event: Dict, room_id: str = "", is_dm: bool = False) -> Optional[Dict]:
+        if not isinstance(raw_event, dict):
+            return None
+
+        event_type = raw_event.get("type", "")
+        event_id = raw_event.get("event_id", str(uuid.uuid4()))
+
+        origin_server_ts = raw_event.get("origin_server_ts", 0)
+        if origin_server_ts:
+            if origin_server_ts > 10**12:
+                event_time = int(origin_server_ts / 1000)
+            else:
+                event_time = int(origin_server_ts)
+        else:
+            event_time = int(time.time())
+
+        sender = raw_event.get("sender", "")
+        if sender == self.bot_user_id:
+            return None
+
+        base_event = {
+            "id": event_id,
+            "time": event_time,
+            "type": "",
+            "detail_type": "",
+            "platform": "matrix",
+            "self": {
+                "platform": "matrix",
+                "user_id": self.bot_user_id,
+            },
+            "matrix_raw": raw_event,
+            "matrix_raw_type": event_type,
+        }
+
+        if is_dm:
+            base_event["detail_type"] = "private"
+        else:
+            base_event["detail_type"] = "group"
+
+        handler = getattr(self, f"_handle_{event_type.replace('.', '_')}", None)
+        if handler:
+            return handler(raw_event, base_event, room_id, is_dm)
+
+        if event_type.startswith("m.room."):
+            return self._handle_m_room_generic(raw_event, base_event, room_id, is_dm)
+
+        return self._create_unknown_event(raw_event, event_id, event_type)
+
+    def _handle_m_room_message(self, raw_event: Dict, base_event: Dict, room_id: str, is_dm: bool) -> Dict:
+        base_event["type"] = "message"
+        base_event["user_id"] = raw_event.get("sender", "")
+        base_event["user_nickname"] = raw_event.get("sender", "")
+
+        content = raw_event.get("content", {})
+        msgtype = content.get("msgtype", "m.text")
+
+        message_segments = self._parse_message_content(content, raw_event)
+        alt_message = self._generate_alt_message(message_segments)
+
+        base_event["message"] = message_segments
+        base_event["alt_message"] = alt_message
+
+        if room_id:
+            base_event["matrix_room_id"] = room_id
+            if is_dm:
+                pass
+            else:
+                base_event["group_id"] = room_id
+
+        relates_to = content.get("m.relates_to", {})
+        if relates_to:
+            rel_type = relates_to.get("rel_type", "")
+            if rel_type == "m.in_reply_to":
+                reply_event_id = relates_to.get("event_id", "")
+                if reply_event_id:
+                    reply_seg = {"type": "reply", "data": {"message_id": reply_event_id}}
+                    base_event["message"].insert(0, reply_seg)
+            elif rel_type == "m.thread":
+                base_event["thread_id"] = relates_to.get("event_id", "")
+
+        new_content = content.get("m.new_content")
+        if new_content:
+            base_event["matrix_edit"] = True
+            base_event["matrix_original_event_id"] = relates_to.get("event_id", "")
+
+        return base_event
+
+    def _handle_m_room_member(self, raw_event: Dict, base_event: Dict, room_id: str, is_dm: bool) -> Dict:
+        base_event["type"] = "notice"
+        base_event["user_id"] = raw_event.get("sender", "")
+        base_event["user_nickname"] = raw_event.get("sender", "")
+
+        content = raw_event.get("content", {})
+        prev_content = raw_event.get("unsigned", {}).get("prev_content", {})
+        membership = content.get("membership", "")
+        prev_membership = prev_content.get("membership", "")
+
+        state_key = raw_event.get("state_key", "")
+        target_user = state_key
+
+        if membership == "join" and prev_membership != "join":
+            base_event["detail_type"] = "group_member_increase"
+            base_event["user_id"] = target_user
+            displayname = content.get("displayname", target_user)
+            base_event["user_nickname"] = displayname
+            base_event["operator_id"] = raw_event.get("sender", "")
+            base_event["group_id"] = room_id
+            base_event["matrix_room_id"] = room_id
+        elif membership in ("leave", "ban") and prev_membership == "join":
+            base_event["detail_type"] = "group_member_decrease"
+            base_event["user_id"] = target_user
+            base_event["user_nickname"] = content.get("displayname", target_user)
+            base_event["operator_id"] = raw_event.get("sender", "")
+            base_event["group_id"] = room_id
+            base_event["matrix_room_id"] = room_id
+        else:
+            base_event["detail_type"] = "matrix_member_update"
+            base_event["user_id"] = target_user
+            base_event["group_id"] = room_id
+            base_event["matrix_room_id"] = room_id
+            base_event["matrix_membership"] = membership
+
+        return base_event
+
+    def _handle_m_reaction(self, raw_event: Dict, base_event: Dict, room_id: str, is_dm: bool) -> Dict:
+        base_event["type"] = "notice"
+        base_event["detail_type"] = "matrix_reaction"
+        base_event["user_id"] = raw_event.get("sender", "")
+        base_event["matrix_room_id"] = room_id
+        if not is_dm:
+            base_event["group_id"] = room_id
+
+        content = raw_event.get("content", {})
+        relates_to = content.get("m.relates_to", {})
+        base_event["matrix_reaction_event_id"] = relates_to.get("event_id", "")
+        base_event["matrix_reaction_key"] = relates_to.get("key", "")
+
+        return base_event
+
+    def _handle_m_room_redaction(self, raw_event: Dict, base_event: Dict, room_id: str, is_dm: bool) -> Dict:
+        base_event["type"] = "notice"
+        base_event["detail_type"] = "matrix_redaction"
+        base_event["user_id"] = raw_event.get("sender", "")
+        base_event["matrix_room_id"] = room_id
+        if not is_dm:
+            base_event["group_id"] = room_id
+
+        redacts = raw_event.get("redacts", "")
+        base_event["matrix_redacted_event_id"] = redacts
+
+        return base_event
+
+    def _handle_m_room_generic(self, raw_event: Dict, base_event: Dict, room_id: str, is_dm: bool) -> Dict:
+        event_type = raw_event.get("type", "")
+        base_event["type"] = "notice"
+        base_event["detail_type"] = f"matrix_{event_type.replace('.', '_').replace('m_room_', '')}"
+        base_event["user_id"] = raw_event.get("sender", "")
+        base_event["matrix_room_id"] = room_id
+        if not is_dm:
+            base_event["group_id"] = room_id
+
+        return base_event
+
+    def _parse_message_content(self, content: Dict, raw_event: Dict) -> List[Dict]:
+        segments = []
+        msgtype = content.get("msgtype", "m.text")
+        body = content.get("body", "")
+        formatted_body = content.get("formatted_body", "")
+
+        if msgtype in ("m.text", "m.notice", "m.emote"):
+            seg_data = {"text": body}
+            if formatted_body:
+                seg_data["html"] = formatted_body
+            segments.append({"type": "text", "data": seg_data})
+
+        elif msgtype == "m.image":
+            url = content.get("url", "")
+            segments.append({
+                "type": "image",
+                "data": {
+                    "url": url,
+                    "filename": body,
+                    "matrix_mxc": url,
+                    "info": content.get("info", {}),
+                },
+            })
+
+        elif msgtype == "m.audio":
+            url = content.get("url", "")
+            segments.append({
+                "type": "voice",
+                "data": {
+                    "url": url,
+                    "filename": body,
+                    "matrix_mxc": url,
+                    "info": content.get("info", {}),
+                },
+            })
+
+        elif msgtype == "m.video":
+            url = content.get("url", "")
+            segments.append({
+                "type": "video",
+                "data": {
+                    "url": url,
+                    "filename": body,
+                    "matrix_mxc": url,
+                    "info": content.get("info", {}),
+                },
+            })
+
+        elif msgtype == "m.file":
+            url = content.get("url", "")
+            segments.append({
+                "type": "file",
+                "data": {
+                    "url": url,
+                    "filename": body,
+                    "matrix_mxc": url,
+                    "info": content.get("info", {}),
+                },
+            })
+
+        elif msgtype == "m.location":
+            geo_uri = content.get("geo_uri", "")
+            segments.append({
+                "type": "location",
+                "data": {
+                    "latitude": 0.0,
+                    "longitude": 0.0,
+                    "matrix_geo_uri": geo_uri,
+                    "text": body,
+                },
+            })
+
+        return segments
+
+    def _create_unknown_event(self, raw_event: Dict, event_id: str, event_type: str) -> Dict:
+        return {
+            "id": event_id,
+            "time": int(time.time()),
+            "type": "unknown",
+            "detail_type": "unknown",
+            "platform": "matrix",
+            "self": {"platform": "matrix", "user_id": self.bot_user_id},
+            "matrix_raw": raw_event,
+            "matrix_raw_type": event_type,
+            "warning": f"Unsupported event type: {event_type}",
+            "alt_message": "This event type is not supported by this system.",
+        }
+
+    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 == "voice":
+                parts.append("[语音]")
+            elif seg_type == "video":
+                parts.append("[视频]")
+            elif seg_type == "file":
+                parts.append(f"[文件:{data.get('filename', '')}]")
+            elif seg_type == "location":
+                parts.append("[位置]")
+            elif seg_type == "reply":
+                parts.append("[回复]")
+        return " ".join(parts).strip()

MatrixAdapter/Core.py

@@ -0,0 +1,574 @@
+import asyncio
+import aiohttp
+import json
+import mimetypes
+import uuid
+from pathlib import Path
+from typing import Dict, List, Optional
+from ErisPulse import sdk
+from .Converter import MatrixConverter
+from ErisPulse.Core.Event import register_event_mixin, unregister_platform_event_methods
+
+
+class MatrixEventMixin:
+    def get_room_id(self) -> str:
+        return self.get("matrix_room_id", self.get("matrix_raw", {}).get("room_id", ""))
+
+    def get_matrix_event_type(self) -> str:
+        return self.get("matrix_raw", {}).get("type", "")
+
+    def get_matrix_sender(self) -> str:
+        return self.get("matrix_raw", {}).get("sender", "")
+
+    def get_reaction_key(self) -> str:
+        return self.get("matrix_reaction_key", "")
+
+    def is_edited(self) -> bool:
+        return self.get("matrix_edit", False)
+
+    def is_notice(self) -> bool:
+        raw = self.get("matrix_raw", {})
+        content = raw.get("content", {})
+        return content.get("msgtype") == "m.notice"
+
+
+register_event_mixin("matrix", MatrixEventMixin)
+
+
+class MatrixAdapter(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._reply_event_id = None
+            self._mention_users = []
+            self._mention_all = False
+
+        def Text(self, text: str):
+            return self.Raw_ob12([{"type": "text", "data": {"text": text}}])
+
+        def Image(self, file):
+            return self.Raw_ob12([{"type": "image", "data": {"file": file}}])
+
+        def Voice(self, file):
+            return self.Raw_ob12([{"type": "voice", "data": {"file": file}}])
+
+        def Video(self, file):
+            return self.Raw_ob12([{"type": "video", "data": {"file": file}}])
+
+        def File(self, file, filename: str = ""):
+            data = {"file": file}
+            if filename:
+                data["filename"] = filename
+            return self.Raw_ob12([{"type": "file", "data": data}])
+
+        def Notice(self, text: str):
+            return self.Raw_ob12([{"type": "notice", "data": {"text": text}}])
+
+        def Html(self, html: str, fallback: str = ""):
+            return self.Raw_ob12([{"type": "html", "data": {"html": html, "fallback": fallback}}])
+
+        def Reply(self, message_id: str) -> "Send":
+            self._reply_event_id = message_id
+            return self
+
+        def At(self, user_id: str) -> "Send":
+            self._mention_users.append(user_id)
+            return self
+
+        def AtAll(self) -> "Send":
+            self._mention_all = True
+            return self
+
+        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 = []
+            html_parts = []
+            media_file = None
+            media_type = None
+            media_filename = None
+            is_notice = False
+            fallback_text = ""
+            segment_mentions = []
+
+            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 == "notice":
+                    is_notice = True
+                    text_parts.append(data.get("text", ""))
+                elif seg_type == "html":
+                    html_parts.append(data.get("html", ""))
+                    fallback_text = data.get("fallback", "")
+                elif seg_type == "reply":
+                    self._reply_event_id = data.get("message_id", "")
+                elif seg_type == "mention":
+                    user_id = data.get("user_id", "")
+                    if user_id:
+                        text_parts.append(user_id)
+                        segment_mentions.append(user_id)
+                elif seg_type in ("image", "voice", "video", "file"):
+                    file = data.get("file", data.get("url", ""))
+                    if file:
+                        media_file = file
+                        media_type = seg_type
+                        if data.get("filename"):
+                            media_filename = data["filename"]
+
+            if self._mention_users:
+                text_parts.insert(0, " ".join(self._mention_users) + " ")
+            if self._mention_all:
+                text_parts.insert(0, "@room ")
+
+            full_text = "".join(text_parts) or fallback_text or " "
+            full_html = "".join(html_parts) if html_parts else None
+
+            target_room = self._target_id
+            content = None
+
+            if media_file and isinstance(media_file, bytes):
+                mxc_uri = await self._adapter._upload_media(media_file, media_type)
+                if not mxc_uri:
+                    return {
+                        "status": "failed",
+                        "retcode": 32000,
+                        "data": None,
+                        "message_id": "",
+                        "message": "媒体上传失败",
+                        "matrix_raw": None,
+                    }
+                content = self._build_media_content(media_type, mxc_uri, media_filename or full_text)
+            elif media_file and isinstance(media_file, str) and media_file.startswith("mxc://"):
+                content = self._build_media_content(media_type, media_file, media_filename or full_text)
+            elif media_file and isinstance(media_file, str) and media_file.startswith(("http://", "https://")):
+                result = await self._adapter._download_file(media_file)
+                if not result:
+                    return {
+                        "status": "failed",
+                        "retcode": 32000,
+                        "data": None,
+                        "message_id": "",
+                        "message": "媒体下载失败",
+                        "matrix_raw": None,
+                    }
+                file_bytes, download_ct = result
+                upload_ct = download_ct if download_ct and "text/" not in download_ct else None
+                mxc_uri = await self._adapter._upload_media(file_bytes, media_type, content_type=upload_ct)
+                if not mxc_uri:
+                    return {
+                        "status": "failed",
+                        "retcode": 32000,
+                        "data": None,
+                        "message_id": "",
+                        "message": "媒体上传失败",
+                        "matrix_raw": None,
+                    }
+                mimetype = upload_ct
+                content = self._build_media_content(media_type, mxc_uri, media_filename or full_text, mimetype=mimetype)
+            elif media_file:
+                path = Path(str(media_file))
+                if path.is_file():
+                    file_bytes = path.read_bytes()
+                    guessed_type, _ = mimetypes.guess_type(str(path))
+                    mxc_uri = await self._adapter._upload_media(file_bytes, media_type, content_type=guessed_type)
+                    if not mxc_uri:
+                        return {
+                            "status": "failed",
+                            "retcode": 32000,
+                            "data": None,
+                            "message_id": "",
+                            "message": "媒体上传失败",
+                            "matrix_raw": None,
+                        }
+                    content = self._build_media_content(media_type, mxc_uri, media_filename or path.name or full_text, mimetype=guessed_type)
+
+            if content is None:
+                content = {
+                    "msgtype": "m.notice" if is_notice else "m.text",
+                    "body": full_text,
+                }
+                if full_html:
+                    content["format"] = "org.matrix.custom.html"
+                    content["formatted_body"] = full_html
+
+            if self._reply_event_id:
+                content["m.relates_to"] = {
+                    "rel_type": "m.in_reply_to",
+                    "event_id": self._reply_event_id,
+                }
+                self._reply_event_id = None
+
+            all_mentioned = list(set(self._mention_users + segment_mentions))
+            if all_mentioned or self._mention_all:
+                content["m.mentions"] = {}
+                if all_mentioned:
+                    content["m.mentions"]["user_ids"] = all_mentioned
+                if self._mention_all:
+                    content["m.mentions"]["room"] = True
+
+            txn_id = str(uuid.uuid4())
+            endpoint = f"/_matrix/client/v3/rooms/{target_room}/send/m.room.message/{txn_id}"
+
+            return await self._adapter.call_api(endpoint=endpoint, method="PUT", **content)
+
+        def _build_media_content(self, media_type: str, mxc_uri: str, body: str, mimetype: str = None) -> Dict:
+            msgtype_map = {
+                "image": "m.image",
+                "voice": "m.audio",
+                "video": "m.video",
+                "file": "m.file",
+            }
+            if not mimetype:
+                mimetype_map = {
+                    "image": "image/png",
+                    "voice": "audio/ogg",
+                    "video": "video/mp4",
+                    "file": "application/octet-stream",
+                }
+                mimetype = mimetype_map.get(media_type, "application/octet-stream")
+            return {
+                "msgtype": msgtype_map.get(media_type, "m.file"),
+                "body": body or media_type,
+                "url": mxc_uri,
+                "info": {
+                    "mimetype": mimetype,
+                },
+            }
+
+    def __init__(self, sdk):
+        super().__init__()
+        self.sdk = sdk
+        self.logger = sdk.logger
+        self.config = self._load_config()
+        self.homeserver = self.config.get("homeserver", "https://matrix.org").rstrip("/")
+        self.access_token = self.config.get("access_token", "")
+        self.bot_id = ""
+        self.session: Optional[aiohttp.ClientSession] = None
+        self._sync_task: Optional[asyncio.Task] = None
+        self._heartbeat_meta_task: Optional[asyncio.Task] = None
+        self._next_batch: Optional[str] = None
+        self._dm_rooms: Dict[str, str] = {}
+        self._running = False
+
+        self.converter = MatrixConverter()
+        self.convert = self.converter.convert
+
+        if not self.access_token and self.config.get("user_id") and self.config.get("password"):
+            pass
+
+    def _load_config(self):
+        config = self.sdk.config.getConfig("Matrix_Adapter")
+        if not config:
+            default_config = {
+                "homeserver": "https://matrix.org",
+                "access_token": "YOUR_ACCESS_TOKEN",
+                "user_id": "",
+                "password": "",
+            }
+            try:
+                self.sdk.config.setConfig("Matrix_Adapter", default_config)
+                self.logger.warning("Matrix适配器配置不存在，已自动创建默认配置")
+            except Exception as e:
+                self.logger.error(f"保存默认配置失败: {e}")
+            return default_config
+        return config
+
+    async def _login_if_needed(self):
+        if self.access_token:
+            try:
+                result = await self.call_api(endpoint="/_matrix/client/v3/account/whoami", method="GET")
+                if result.get("status") == "ok" and result.get("data"):
+                    self.bot_id = result["data"].get("user_id", "")
+                    self.converter.bot_user_id = self.bot_id
+                    self.logger.info(f"Matrix 已认证: {self.bot_id}")
+                    return
+            except Exception:
+                pass
+
+        user_id = self.config.get("user_id", "")
+        password = self.config.get("password", "")
+        if user_id and password:
+            try:
+                login_data = {
+                    "type": "m.login.password",
+                    "identifier": {"type": "m.id.user", "user": user_id},
+                    "password": password,
+                }
+                result = await self.call_api(endpoint="/_matrix/client/v3/login", method="POST", **login_data)
+                if result.get("status") == "ok" and result.get("data"):
+                    self.access_token = result["data"].get("access_token", "")
+                    self.bot_id = result["data"].get("user_id", user_id)
+                    self.converter.bot_user_id = self.bot_id
+                    self.logger.info(f"Matrix 登录成功: {self.bot_id}")
+                else:
+                    raise Exception(f"登录失败: {result.get('message', 'Unknown error')}")
+            except Exception as e:
+                self.logger.error(f"Matrix 登录失败: {e}")
+                raise
+
+    async def _sync_loop(self):
+        self._running = True
+        await self._initial_sync()
+        await self._discover_dm_rooms()
+
+        while self._running:
+            try:
+                result = await self.call_api(
+                    endpoint=f"/_matrix/client/v3/sync?since={self._next_batch}&timeout=30000",
+                    method="GET",
+                )
+
+                if result.get("status") != "ok":
+                    self.logger.error(f"同步失败: {result.get('message')}")
+                    await asyncio.sleep(5)
+                    continue
+
+                data = result.get("data", {})
+                self._next_batch = data.get("next_batch", self._next_batch)
+
+                await self._process_sync_response(data)
+
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                self.logger.error(f"同步循环异常: {e}")
+                await asyncio.sleep(5)
+
+    async def _initial_sync(self):
+        result = await self.call_api(
+            endpoint="/_matrix/client/v3/sync?timeout=0",
+            method="GET",
+        )
+        if result.get("status") == "ok" and result.get("data"):
+            data = result["data"]
+            self._next_batch = data.get("next_batch", "")
+            self.logger.info(f"初始同步完成, next_batch: {self._next_batch}")
+
+    async def _discover_dm_rooms(self):
+        result = await self.call_api(
+            endpoint="/_matrix/client/v3/user/{user_id}/account_data/m.direct".format(user_id=self.bot_id),
+            method="GET",
+        )
+        if result.get("status") == "ok" and result.get("data"):
+            dm_data = result["data"]
+            for user_id, room_ids in dm_data.items():
+                if isinstance(room_ids, list) and room_ids:
+                    self._dm_rooms[room_ids[0]] = user_id
+            self.converter.set_dm_rooms(self._dm_rooms)
+            self.logger.info(f"发现 {len(self._dm_rooms)} 个 DM 房间")
+
+    async def _process_sync_response(self, data: dict):
+        joined_rooms = data.get("rooms", {}).get("join", {})
+        for room_id, room_data in joined_rooms.items():
+            is_dm = room_id in self._dm_rooms
+
+            timeline = room_data.get("timeline", {})
+            events = timeline.get("events", [])
+
+            for event in events:
+                self.logger.debug(f"处理 Matrix 事件: {event}")
+                try:
+                    onebot_event = self.convert(event, room_id=room_id, is_dm=is_dm)
+                    if onebot_event:
+                        await self.sdk.adapter.emit(onebot_event)
+                except Exception as e:
+                    self.logger.error(f"处理事件失败: {e}")
+
+        invite_rooms = data.get("rooms", {}).get("invite", {})
+        for room_id, room_data in invite_rooms.items():
+            invite_state = room_data.get("invite_state", {}).get("events", [])
+            for event in invite_state:
+                if event.get("type") == "m.room.member":
+                    content = event.get("content", {})
+                    if content.get("membership") == "invite" and event.get("state_key") == self.bot_id:
+                        self.logger.info(f"收到房间邀请: {room_id}")
+                        if self.config.get("auto_accept_invites", True):
+                            try:
+                                await self.call_api(
+                                    endpoint=f"/_matrix/client/v3/join/{room_id}",
+                                    method="POST",
+                                )
+                                self.logger.info(f"已自动加入房间: {room_id}")
+                            except Exception as e:
+                                self.logger.error(f"加入房间失败: {e}")
+
+    async def _download_file(self, url: str) -> Optional[tuple]:
+        try:
+            timeout = aiohttp.ClientTimeout(total=300)
+            async with self.session.get(url, timeout=timeout) as resp:
+                if resp.status != 200:
+                    self.logger.error(f"下载文件失败: HTTP {resp.status}")
+                    return None
+                content_type = resp.headers.get("Content-Type", "").split(";")[0].strip()
+                data = await resp.read()
+                return (data, content_type)
+        except Exception as e:
+            self.logger.error(f"下载文件异常: {e}")
+            return None
+
+    async def _upload_media(self, file: bytes, media_type: str, content_type: str = None) -> Optional[str]:
+        if not content_type:
+            content_type_map = {
+                "image": "image/png",
+                "voice": "audio/ogg",
+                "video": "video/mp4",
+                "file": "application/octet-stream",
+            }
+            content_type = content_type_map.get(media_type, "application/octet-stream")
+
+        url = f"{self.homeserver}/_matrix/media/v3/upload"
+        headers = {
+            "Authorization": f"Bearer {self.access_token}",
+            "Content-Type": content_type,
+        }
+
+        try:
+            async with self.session.post(url, data=file, headers=headers) as resp:
+                data = await resp.json()
+                if resp.status == 200:
+                    return data.get("content_uri", "")
+                else:
+                    self.logger.error(f"上传媒体失败: {data}")
+                    return None
+        except Exception as e:
+            self.logger.error(f"上传媒体异常: {e}")
+            return None
+
+    async def call_api(self, endpoint: str, method: str = "POST", **params):
+        url = f"{self.homeserver}{endpoint}"
+        headers = {"Authorization": f"Bearer {self.access_token}", "Content-Type": "application/json"}
+
+        try:
+            if method.upper() == "GET":
+                async with self.session.get(url, headers=headers) as resp:
+                    raw_response = await resp.json()
+            elif method.upper() == "PUT":
+                async with self.session.put(url, json=params, headers=headers) as resp:
+                    raw_response = await resp.json()
+            else:
+                async with self.session.post(url, json=params, headers=headers) as resp:
+                    raw_response = await resp.json()
+
+            success = 200 <= resp.status < 300
+
+            if not isinstance(raw_response, dict):
+                return {
+                    "status": "ok" if success else "failed",
+                    "retcode": 0 if success else 34000,
+                    "data": raw_response,
+                    "message_id": "",
+                    "message": "",
+                    "matrix_raw": raw_response,
+                }
+
+            event_id = raw_response.get("event_id", "")
+            message_id = str(event_id) if event_id else ""
+            data = dict(raw_response)
+            data["message_id"] = message_id
+
+            return {
+                "status": "ok" if success else "failed",
+                "retcode": 0 if success else raw_response.get("errcode", 34000),
+                "data": data,
+                "message_id": message_id,
+                "message": "" if success else raw_response.get("error", f"HTTP {resp.status}"),
+                "matrix_raw": raw_response,
+            }
+
+        except asyncio.TimeoutError:
+            self.logger.error(f"Matrix API 请求超时: {endpoint}")
+            return {
+                "status": "failed",
+                "retcode": 32000,
+                "data": None,
+                "message_id": "",
+                "message": "请求超时",
+                "matrix_raw": None,
+            }
+        except Exception as e:
+            self.logger.error(f"调用 Matrix API 失败: {e}")
+            return {
+                "status": "failed",
+                "retcode": 33000,
+                "data": None,
+                "message_id": "",
+                "message": f"API调用失败: {str(e)}",
+                "matrix_raw": None,
+            }
+
+    async def _on_connect(self):
+        await self.sdk.adapter.emit({
+            "type": "meta",
+            "detail_type": "connect",
+            "platform": "matrix",
+            "self": {"platform": "matrix", "user_id": self.bot_id},
+        })
+        self._heartbeat_meta_task = asyncio.create_task(self._heartbeat_meta_loop())
+
+    async def _heartbeat_meta_loop(self):
+        try:
+            while self._running:
+                await asyncio.sleep(30)
+                await self.sdk.adapter.emit({
+                    "type": "meta",
+                    "detail_type": "heartbeat",
+                    "platform": "matrix",
+                    "self": {"platform": "matrix", "user_id": self.bot_id},
+                })
+        except asyncio.CancelledError:
+            pass
+
+    async def start(self):
+        self.session = aiohttp.ClientSession()
+
+        await self._login_if_needed()
+
+        if not self.bot_id:
+            self.logger.error("无法获取 bot user_id，请检查配置")
+            if self.session:
+                await self.session.close()
+            raise Exception("Authentication failed")
+
+        await self._on_connect()
+
+        self._sync_task = asyncio.create_task(self._sync_loop())
+        self.logger.info("Matrix 适配器已启动")
+
+    async def shutdown(self):
+        self._running = False
+
+        if self.bot_id:
+            await self.sdk.adapter.emit({
+                "type": "meta",
+                "detail_type": "disconnect",
+                "platform": "matrix",
+                "self": {"platform": "matrix", "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._sync_task:
+            self._sync_task.cancel()
+            try:
+                await self._sync_task
+            except asyncio.CancelledError:
+                pass
+            self._sync_task = None
+
+        if self.session:
+            await self.session.close()
+            self.session = None
+
+        self._dm_rooms.clear()
+        unregister_platform_event_methods("matrix")
+        self.logger.info("Matrix 适配器已关闭")

MatrixAdapter/__init__.py

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

erispulse_matrixadapter-1.0.0.dist-info/METADATA

@@ -0,0 +1,209 @@
+Metadata-Version: 2.4
+Name: ErisPulse-MatrixAdapter
+Version: 1.0.0
+Summary: ErisPulse的Matrix协议适配模块
+Author-email: wsu2059 <wsu2059@qq.com>
+Project-URL: homepage, https://github.com/ErisPulse/ErisPulse-MatrixAdapter
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.8.0
+
+# MatrixAdapter 模块文档
+
+## 简介
+MatrixAdapter 是基于 [ErisPulse](https://github.com/ErisPulse/ErisPulse/) 架构的 Matrix 协议适配器，通过 Long Polling Sync API 接收事件，整合了私聊、群组等多种场景的功能模块，提供统一的事件处理和消息操作接口。
+
+## 使用示例
+
+### OneBot12标准事件类型
+
+MatrixAdapter 适配器完全兼容 OneBot12 标准事件格式，并提供了一些扩展字段：
+
+| 事件类型 | detail_type | 说明 |
+|----------|-------------|------|
+| 消息事件（私聊） | private | DM房间中用户发送的消息 |
+| 消息事件（群组） | group | 群组房间中用户发送的消息 |
+| 群成员增加 | group_member_increase | 用户加入房间 |
+| 群成员减少 | group_member_decrease | 用户离开/被封禁 |
+| 成员信息更新 | matrix_member_update | 房间成员信息变更 |
+| Matrix表情回应 | matrix_reaction | 消息表情回应 |
+| Matrix消息撤回 | matrix_redaction | 消息被撤回/删除 |
+| Matrix房间名称变更 | matrix_name | 房间名称变更 |
+| Matrix房间话题变更 | matrix_topic | 房间话题变更 |
+| Matrix房间头像变更 | matrix_avatar | 房间头像变更 |
+| Matrix权限等级变更 | matrix_power_levels | 房间权限变更 |
+
+---
+
+## 消息发送示例
+
+```python
+from ErisPulse import sdk
+matrix = sdk.adapter.get("matrix")
+
+# 发送文本消息
+await matrix.Send.To("group", room_id).Text("Hello World!")
+
+# 发送带@的消息
+await matrix.Send.To("group", room_id).At("@user:matrix.org").Text("你好")
+
+# 发送带@所有人的消息
+await matrix.Send.To("group", room_id).AtAll().Text("公告通知")
+
+# 发送回复消息
+await matrix.Send.To("group", room_id).Reply("$event_id").Text("回复内容")
+
+# 发送图片（URL）
+await matrix.Send.To("group", room_id).Image("https://example.com/image.png")
+
+# 发送图片（MXC URI）
+await matrix.Send.To("group", room_id).Image("mxc://matrix.org/abc123")
+
+# 发送图片（二进制数据）
+with open("image.png", "rb") as f:
+    image_data = f.read()
+await matrix.Send.To("group", room_id).Image(image_data)
+
+# 发送图片（本地文件路径）
+await matrix.Send.To("group", room_id).Image("/path/to/image.png")
+
+# 发送通知消息（m.notice）
+await matrix.Send.To("group", room_id).Notice("系统通知")
+
+# 发送HTML格式消息
+await matrix.Send.To("group", room_id).Html("<b>加粗</b> <i>斜体</i>", fallback="加粗 斜体")
+
+# 发送文件（带文件名）
+await matrix.Send.To("group", room_id).File("/path/to/file.pdf", filename="文档.pdf")
+
+# 组合使用：回复 + @
+await matrix.Send.To("group", room_id).Reply("$event_id").At("@user:matrix.org").Text("复合消息")
+
+# 使用 Raw_ob12 发送 OneBot12 格式消息
+message = [
+    {"type": "text", "data": {"text": "第一行"}},
+    {"type": "image", "data": {"file": "https://example.com/img.jpg"}},
+    {"type": "text", "data": {"text": "第二行"}}
+]
+await matrix.Send.To("group", room_id).Raw_ob12(message)
+```
+
+---
+
+### 配置说明
+
+首次运行会自动生成默认配置。
+
+```toml
+# config.toml
+[Matrix_Adapter]
+homeserver = "https://matrix.org"          # Matrix服务器地址（必填）
+access_token = "YOUR_ACCESS_TOKEN"          # 访问令牌（与 user_id+password 二选一）
+user_id = ""                                # Matrix用户ID（如 @bot:matrix.org）
+password = ""                               # Matrix用户密码
+auto_accept_invites = true                  # 是否自动接受房间邀请（可选，默认为true）
+```
+
+**配置项说明：**
+- `homeserver`：Matrix服务器地址（必填），默认为 `https://matrix.org`
+- `access_token`：访问令牌，可从Matrix客户端（如 Element）的设置中获取
+- `user_id`：Matrix用户ID（如 `@bot:matrix.org`），与 `password` 配合使用
+- `password`：Matrix用户密码，用于自动登录获取 access_token
+- `auto_accept_invites`：是否自动接受房间邀请，默认为 `true`
+
+**认证方式：**
+- 方式一（推荐）：直接提供 `access_token`
+- 方式二：提供 `user_id` 和 `password`，适配器会自动调用登录接口获取 token
+
+---
+
+## Matrix平台特有功能
+
+请参考 [Matrix平台特性文档](platform-features.md) 了解Matrix平台的特有功能，包括去中心化架构、房间概念、Long Polling同步、MXC URI、HTML富文本、表情回应、消息编辑、扩展字段说明等内容。
+
+详细的事件转换对照请参考 [转换对照文档](CoverToOnebot12.md)。
+
+## 事件监听示例
+
+### 使用 Event 模块（推荐）
+
+```python
+from ErisPulse.Core.Event import message, notice
+
+@message.on_message()
+async def handle_message(event):
+    if event["platform"] == "matrix":
+        detail_type = event["detail_type"]
+        if detail_type == "private":
+            # 处理私聊消息
+            pass
+        elif detail_type == "group":
+            # 处理群组消息
+            pass
+
+@notice.on_notice()
+async def handle_notice(event):
+    if event["platform"] == "matrix":
+        detail_type = event["detail_type"]
+        if detail_type == "matrix_reaction":
+            # 处理表情回应
+            reaction_key = event.get("matrix_reaction_key", "")
+        elif detail_type == "matrix_redaction":
+            # 处理消息撤回
+            redacted_id = event.get("matrix_redacted_event_id", "")
+        elif detail_type == "group_member_increase":
+            # 处理成员加入
+            user_id = event.get("user_id", "")
+```
+
+### 使用 OneBot12 标准事件
+
+```python
+@sdk.adapter.on("message")
+async def handle_message(event):
+    if event["platform"] == "matrix":
+        bot_id = event["self"]["user_id"]
+        print(f"消息来自Bot: {bot_id}")
+
+@sdk.adapter.on("notice")
+async def handle_notice(event):
+    if event["platform"] == "matrix":
+        # 处理Matrix通知事件
+        pass
+```
+
+### 使用 Event Mixin 方法
+
+```python
+@message.on_message()
+async def handle_message(event):
+    if event.get("platform") != "matrix":
+        return
+
+    room_id = event.get_room_id()           # 获取房间ID
+    event_type = event.get_matrix_event_type()  # 获取原始Matrix事件类型
+    sender = event.get_matrix_sender()      # 获取发送者ID
+    is_edited = event.is_edited()           # 是否为编辑消息
+    is_notice = event.is_notice()           # 是否为 m.notice 类型
+```
+
+## 注意事项：
+
+1. 确保在调用 `startup()` 前完成所有处理器的注册
+2. Matrix 是去中心化协议，用户ID格式为 `@user:server.domain`，房间ID格式为 `!room_id:server.domain`
+3. Matrix 不区分群聊和私聊，所有会话都是"房间"。适配器通过 DM 账户数据自动识别私聊
+4. 适配器使用 Long Polling（`/sync` API）获取事件，而非 WebSocket
+5. 媒体文件通过 `mxc://` URI 引用，适配器支持自动上传和下载
+6. 程序退出时请调用 `shutdown()` 确保资源释放
+7. 支持自动接受房间邀请（可通过 `auto_accept_invites` 配置关闭）
+8. 支持发送 HTML 格式消息，使用 `.Html()` 方法
+9. 支持消息回复（`.Reply()`）和用户提及（`.At()`、`.AtAll()`）
+
+---
+
+### 参考链接
+
+- [ErisPulse 主库](https://github.com/ErisPulse/ErisPulse/)
+- [Matrix 协议规范](https://spec.matrix.org/)
+- [Matrix Client-Server API](https://spec.matrix.org/v1.11/client-server-api/)
+- [模块开发指南](https://www.erisdev.com/#docs/developer-guide/README.md)

erispulse_matrixadapter-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+MatrixAdapter/Converter.py,sha256=qUkDx9TzqWJeET8eZKYgmNnj4yUCO0_eH-mD3U5TBHI,10662
+MatrixAdapter/Core.py,sha256=hFPlqE-1sP8ohWptjME9sY8pD1uz6zJWRIaEYrXr-SI,23319
+MatrixAdapter/__init__.py,sha256=91-9JWoF_G3Nj6ddKoX4rYy7doT2hqNjUaNEgZG_eRM,32
+erispulse_matrixadapter-1.0.0.dist-info/METADATA,sha256=EpeFRKIpmOY0my6zKaltqYnCdYrLGff6ynbj0h4Z7rA,7778
+erispulse_matrixadapter-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+erispulse_matrixadapter-1.0.0.dist-info/entry_points.txt,sha256=Dmpp8-f_kLjGuKW7AAgvOHYz-FTu0J9VEZrcPizSVMU,57
+erispulse_matrixadapter-1.0.0.dist-info/top_level.txt,sha256=rxVrq_fa3bzS5NhrvoY_QyNdsuY_SwumstPZ38NiR6E,14
+erispulse_matrixadapter-1.0.0.dist-info/RECORD,,

erispulse_matrixadapter-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_matrixadapter-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[erispulse.adapter]
+matrix = MatrixAdapter:MatrixAdapter

erispulse_matrixadapter-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+MatrixAdapter