From 29dfae1518c3021f009e6658fad912369351ba00 Mon Sep 17 00:00:00 2001
From: Typer_Body <mcjiekejiemi@163.com>
Date: Thu, 12 Feb 2026 02:44:47 +0800
Subject: [PATCH] Add files via upload

---
 src/langbot/pkg/platform/sources/satori.png  |  Bin 0 -> 10663 bytes
 src/langbot/pkg/platform/sources/satori.py   | 1015 ++++++++++++++++++
 src/langbot/pkg/platform/sources/satori.yaml |   65 ++
 3 files changed, 1080 insertions(+)
 create mode 100644 src/langbot/pkg/platform/sources/satori.png
 create mode 100644 src/langbot/pkg/platform/sources/satori.py
 create mode 100644 src/langbot/pkg/platform/sources/satori.yaml

diff --git a/src/langbot/pkg/platform/sources/satori.png b/src/langbot/pkg/platform/sources/satori.png
new file mode 100644
index 0000000000000000000000000000000000000000..8a12cc6da189c1fa7e0ce8bdacf6127cd2cdaabe
GIT binary patch
literal 10663
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
N002ovPDHLkV1lqNSX2N2

literal 0
HcmV?d00001

diff --git a/src/langbot/pkg/platform/sources/satori.py b/src/langbot/pkg/platform/sources/satori.py
new file mode 100644
index 00000000..31ac21dd
--- /dev/null
+++ b/src/langbot/pkg/platform/sources/satori.py
@@ -0,0 +1,1015 @@
+from __future__ import annotations
+
+import typing
+import time
+import datetime
+import json
+import asyncio
+import traceback
+import re
+import base64
+
+import aiohttp
+import pydantic
+import websockets
+
+import langbot_plugin.api.definition.abstract.platform.adapter as abstract_platform_adapter
+import langbot_plugin.api.entities.builtin.platform.message as platform_message
+import langbot_plugin.api.entities.builtin.platform.events as platform_events
+import langbot_plugin.api.entities.builtin.platform.entities as platform_entities
+import langbot_plugin.api.definition.abstract.platform.event_logger as abstract_platform_logger
+
+
+class SatoriMessageConverter(abstract_platform_adapter.AbstractMessageConverter):
+    """Convert between LangBot MessageChain and Satori message format"""
+
+    @staticmethod
+    async def yiri2target(
+        message_chain: platform_message.MessageChain, adapter: "SatoriAdapter"
+    ) -> str:
+        """Convert LangBot MessageChain to Satori message format"""
+        content_parts = []
+
+        for component in message_chain:
+            if isinstance(component, platform_message.Plain):
+                text = component.text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+                content_parts.append(text)
+            elif isinstance(component, platform_message.Image):
+                # Prefer URL over base64 to avoid buffer overflow issues with large images
+                if component.url:
+                    content_parts.append(f'<img src="{component.url}"/>')
+                elif hasattr(component, "base64") and component.base64:
+                    # Process base64 data
+                    base64_data = component.base64
+                    # Remove whitespace that might corrupt the data
+                    base64_data = base64_data.replace('\n', '').replace('\r', '').replace(' ', '')
+                    
+                    # Check size - if too large, try to upload
+                    MAX_INLINE_SIZE = 32 * 1024  # 32KB limit for inline base64
+                    
+                    # Extract raw base64 and mime type
+                    raw_b64 = base64_data
+                    mime_type = "image/png"
+                    if base64_data.startswith("data:"):
+                        try:
+                            header, raw_b64 = base64_data.split(',', 1)
+                            if ';' in header:
+                                mime_type = header.split(':')[1].split(';')[0]
+                        except (ValueError, IndexError):
+                            pass
+                    
+                    if len(raw_b64) > MAX_INLINE_SIZE:
+                        # Try to upload large image
+                        try:
+                            # Fix base64 padding if needed
+                            padding = 4 - len(raw_b64) % 4
+                            if padding != 4:
+                                raw_b64 += '=' * padding
+                            image_bytes = base64.b64decode(raw_b64)
+                            uploaded_url = await adapter.upload_image(image_bytes, mime_type)
+                            if uploaded_url:
+                                await adapter.logger.info(f"Satori 图片上传成功: {len(image_bytes)} 字节")
+                                content_parts.append(f'<img src="{uploaded_url}"/>')
+                            else:
+                                # Upload failed, use inline (may fail)
+                                await adapter.logger.warning("Satori 图片上传失败，使用内联模式")
+                                content_parts.append(f'<img src="data:{mime_type};base64,{raw_b64}"/>')
+                        except Exception as e:
+                            await adapter.logger.error(f"Satori 图片处理失败: {e}")
+                            content_parts.append(f'<img src="data:{mime_type};base64,{raw_b64}"/>')
+                    else:
+                        # Small image, use inline
+                        content_parts.append(f'<img src="data:{mime_type};base64,{raw_b64}"/>')
+            elif isinstance(component, platform_message.At):
+                if component.target:
+                    content_parts.append(f'<at id="{component.target}"/>')
+            elif isinstance(component, platform_message.AtAll):
+                content_parts.append('<at type="all"/>')
+            elif isinstance(component, platform_message.Reply):
+                content_parts.append(f'<reply id="{component.id}"/>')
+            elif isinstance(component, platform_message.Quote):
+                content_parts.append(f'<quote id="{component.message_id}"/>')
+            elif isinstance(component, platform_message.Face):
+                # Satori中的表情可以使用emoticon元素
+                face_id = getattr(component, 'face_id', 'unknown')
+                content_parts.append(f'<emoticon id="{face_id}"/>')
+            elif isinstance(component, platform_message.Voice):
+                if hasattr(component, 'url') and component.url:
+                    content_parts.append(f'<audio src="{component.url}"/>')
+            elif isinstance(component, platform_message.File):
+                if hasattr(component, 'url') and component.url:
+                    content_parts.append(f'<file url="{component.url}" name="{getattr(component, "name", "")}"/>')
+
+        return "".join(content_parts)
+
+    @staticmethod
+    async def target2yiri(
+        message_data: dict, adapter: "SatoriAdapter", bot_account_id: str = ""
+    ) -> platform_message.MessageChain:
+        """Convert Satori message to LangBot MessageChain
+        
+        Parses Satori's XML-like message format and converts to LangBot MessageChain.
+        Handles text, images, mentions, replies, quotes, emoticons, audio, and files.
+        """
+        content = message_data.get("content", "")
+
+        components = []
+        
+        if content:
+            # HTML实体解码 - 注意顺序：先解码 &amp; 再解码其他实体
+            # 这样可以正确处理 &amp;lt; -> &lt; -> <
+            content = content.replace("&amp;", "&").replace("&lt;", "<").replace("&gt;", ">")
+            
+            # 定义各种消息组件的正则模式 - 支持更灵活的属性顺序
+            # 使用 (?:...) 非捕获组来支持可选属性
+            patterns = [
+                # 图片 - 支持 src 在任意位置
+                (r'<img\s+[^>]*src=["\']([^"\']+)["\'][^>]*/?\s*>', "image"),
+                # @提及用户 - id 属性
+                (r'<at\s+[^>]*id=["\']([^"\']+)["\'][^>]*/?\s*>', "mention"),
+                # @全体 - type="all"
+                (r'<at\s+[^>]*type=["\']all["\'][^>]*/?\s*>', "mention_all"),
+                # 回复
+                (r'<reply\s+[^>]*id=["\']([^"\']+)["\'][^>]*/?\s*>', "reply"),
+                # 引用
+                (r'<quote\s+[^>]*id=["\']([^"\']+)["\'][^>]*/?\s*>', "quote"),
+                # 表情
+                (r'<emoticon\s+[^>]*id=["\']([^"\']+)["\'][^>]*/?\s*>', "emoticon"),
+                (r'<face\s+[^>]*id=["\']([^"\']+)["\'][^>]*/?\s*>', "face"),
+                # 音频
+                (r'<audio\s+[^>]*src=["\']([^"\']+)["\'][^>]*/?\s*>', "audio"),
+                (r'<record\s+[^>]*(?:src|url)=["\']([^"\']+)["\'][^>]*/?\s*>', "audio"),
+                # 视频
+                (r'<video\s+[^>]*src=["\']([^"\']+)["\'][^>]*/?\s*>', "video"),
+                # 文件 - 支持 url 或 src 属性
+                (r'<file\s+[^>]*(?:url|src)=["\']([^"\']+)["\'][^>]*/?\s*>', "file"),
+            ]
+            
+            # 构建联合正则表达式
+            combined_pattern = '|'.join([f'({p[0]})' for p in patterns])
+            
+            # 分割消息内容，按顺序处理各种组件
+            pos = 0
+            for match in re.finditer(combined_pattern, content, re.IGNORECASE):
+                # 添加匹配前的纯文本
+                if pos < match.start():
+                    text = content[pos:match.start()]
+                    # 保留文本（包括空白），但跳过完全空的文本
+                    if text:
+                        components.append(platform_message.Plain(text=text))
+                
+                # 处理匹配到的组件
+                match_text = match.group(0)
+                matched = False
+                for pattern, msg_type in patterns:
+                    sub_match = re.search(pattern, match_text, re.IGNORECASE)
+                    if sub_match:
+                        matched = True
+                        if msg_type == "image":
+                            img_url = sub_match.group(1)
+                            components.append(platform_message.Image(url=img_url))
+                        elif msg_type == "mention":
+                            target_id = sub_match.group(1)
+                            components.append(platform_message.At(target=str(target_id)))
+                        elif msg_type == "mention_all":
+                            components.append(platform_message.AtAll())
+                        elif msg_type == "reply":
+                            reply_id = sub_match.group(1)
+                            components.append(platform_message.Reply(id=str(reply_id)))
+                        elif msg_type == "quote":
+                            quote_id = sub_match.group(1)
+                            # Quote requires origin field - use empty list as placeholder
+                            components.append(platform_message.Quote(message_id=str(quote_id), origin=[]))
+                        elif msg_type == "emoticon" or msg_type == "face":
+                            emoticon_id = sub_match.group(1)
+                            components.append(platform_message.Face(face_id=str(emoticon_id), face_name=f"emoticon_{emoticon_id}"))
+                        elif msg_type == "audio":
+                            audio_url = sub_match.group(1)
+                            components.append(platform_message.Voice(url=audio_url))
+                        elif msg_type == "video":
+                            # 视频作为文件处理
+                            video_url = sub_match.group(1)
+                            components.append(platform_message.File(url=video_url, name="video"))
+                        elif msg_type == "file":
+                            file_url = sub_match.group(1)
+                            # 尝试从标签中提取文件名
+                            name_match = re.search(r'name=["\']([^"\']*)["\']', match_text, re.IGNORECASE)
+                            file_name = name_match.group(1) if name_match else ""
+                            components.append(platform_message.File(url=file_url, name=file_name))
+                        break
+                
+                # 如果没有匹配到任何已知模式，将其作为纯文本
+                if not matched:
+                    components.append(platform_message.Plain(text=match_text))
+                
+                pos = match.end()
+            
+            # 添加剩余的文本
+            if pos < len(content):
+                remaining_text = content[pos:]
+                # 保留文本（包括空白），但跳过完全空的文本
+                if remaining_text:
+                    components.append(platform_message.Plain(text=remaining_text))
+        
+        # 如果没有解析出任何组件，但内容不为空，则作为纯文本
+        if not components and content:
+            components.append(platform_message.Plain(text=content))
+
+        message_chain = platform_message.MessageChain(components)
+        await adapter.logger.info(f"Satori 消息解析完成: 共 {len(components)} 个组件 内容长度={len(content)} 字符")
+        return message_chain
+
+
+class SatoriEventConverter(abstract_platform_adapter.AbstractEventConverter):
+    """Convert between Satori events and LangBot events"""
+
+    @staticmethod
+    def _ensure_string(value: typing.Any, default: str = "") -> str:
+        """Ensure value is string type"""
+        if value is None:
+            return default
+        if isinstance(value, str):
+            return value
+        return str(value)
+
+    @staticmethod
+    async def target2yiri(
+        event_data: dict, adapter: "SatoriAdapter", bot_account_id: str = ""
+    ) -> typing.Optional[platform_events.MessageEvent]:
+        """Convert Satori event to LangBot event
+        
+        This method is used for standalone event conversion.
+        Note: The adapter's convert_satori_message method is preferred for better handling.
+        """
+        event_type = event_data.get("type", "")
+
+        if event_type == "message-created":
+            message = event_data.get("message", {})
+            user = event_data.get("user", {})
+            guild = event_data.get("guild")
+            channel = event_data.get("channel", {})
+            login = event_data.get("login", {})
+
+            user_name = SatoriEventConverter._ensure_string(
+                user.get("name") or user.get("nick"), ""
+            )
+            user_id = SatoriEventConverter._ensure_string(user.get("id"), "")
+            message_id = SatoriEventConverter._ensure_string(message.get("id"), "")
+            message_content = SatoriEventConverter._ensure_string(
+                message.get("content"), ""
+            )
+
+            # Log received message
+            await adapter.logger.info(f"Satori EventConverter 消息接收: 用户ID={user_id}, 用户名={user_name}, 内容长度={len(message_content)}")
+
+            # Convert message content to MessageChain
+            message_chain = await SatoriMessageConverter.target2yiri(
+                {"content": message_content}, adapter, bot_account_id
+            )
+            
+            # Insert Source component at the beginning of the message chain
+            message_chain.insert(0, platform_message.Source(id=message_id, time=datetime.datetime.now()))
+
+            # Build original event object for source_platform_object
+            original_event = {
+                "type": event_type,
+                "message": message,
+                "user": user,
+                "channel": channel,
+                "guild": guild,
+                "login": login,
+            }
+
+            # Try to get timestamp from message or use current time
+            msg_timestamp = message.get("timestamp") or message.get("created_at")
+            if msg_timestamp:
+                try:
+                    if isinstance(msg_timestamp, (int, float)):
+                        event_time = int(msg_timestamp) if msg_timestamp > 1e12 else int(msg_timestamp * 1000)
+                        event_time = event_time // 1000 if event_time > 1e12 else event_time
+                    else:
+                        # Try parsing ISO format
+                        event_time = int(datetime.datetime.fromisoformat(str(msg_timestamp).replace('Z', '+00:00')).timestamp())
+                except (ValueError, TypeError):
+                    event_time = int(time.time())
+            else:
+                event_time = int(time.time())
+
+            # Determine message type based on channel.type or guild presence
+            # In Satori protocol:
+            # - channel.type = 0: TEXT channel (group/guild message)
+            # - channel.type = 1: DIRECT channel (private message)
+            channel_type = channel.get("type")
+            channel_id = SatoriEventConverter._ensure_string(channel.get("id"), "")
+
+            # Check if it's a private/direct message
+            is_private = (channel_type == 1)
+
+            # Check if it's a group message
+            is_group = (guild and guild.get("id")) or (channel_type == 0)
+
+            if is_private:
+                # Private/friend message
+                sender = platform_entities.Friend(
+                    id=user_id,
+                    nickname=user_name,
+                    remark=user_name,
+                )
+                friend_message = platform_events.FriendMessage(
+                    message_chain=message_chain,
+                    sender=sender,
+                    time=event_time,
+                    source_platform_object=original_event,
+                )
+                await adapter.logger.info(f"Satori 私聊消息已构建: 用户ID={user_id}, 用户名={user_name}")
+                return friend_message
+            elif is_group:
+                # Group message
+                # Use guild.id if available, otherwise use channel.id as group_id
+                group_id = SatoriEventConverter._ensure_string(guild.get("id"), "") if guild and guild.get("id") else channel_id
+                group_name = guild.get("name", "Unknown Group") if guild else "Unknown Group"
+
+                group = platform_entities.Group(
+                    id=group_id,
+                    name=group_name,
+                    permission=platform_entities.Permission.Member
+                )
+                sender = platform_entities.GroupMember(
+                    id=user_id,
+                    member_name=user_name,
+                    permission=platform_entities.Permission.Member,
+                    group=group,
+                    special_title='',
+                )
+                group_message = platform_events.GroupMessage(
+                    message_chain=message_chain,
+                    sender=sender,
+                    time=event_time,
+                    source_platform_object=original_event,
+                )
+                await adapter.logger.info(f"Satori 群消息已构建: 群ID={group_id}, 发送者={user_name}")
+                return group_message
+            else:
+                # Fallback: treat as private message if cannot determine type
+                sender = platform_entities.Friend(
+                    id=user_id,
+                    nickname=user_name,
+                    remark=user_name,
+                )
+                friend_message = platform_events.FriendMessage(
+                    message_chain=message_chain,
+                    sender=sender,
+                    time=event_time,
+                    source_platform_object=original_event,
+                )
+                await adapter.logger.info(f"Satori 私聊消息已构建 (fallback): 用户ID={user_id}, 用户名={user_name}")
+                return friend_message
+        return None
+
+
+class SatoriAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
+    """Satori protocol adapter for LangBot - Native implementation"""
+
+    ws: typing.Optional[typing.Any] = pydantic.Field(exclude=True, default=None)
+    session: typing.Optional[aiohttp.ClientSession] = pydantic.Field(
+        exclude=True, default=None
+    )
+    running: bool = pydantic.Field(exclude=True, default=False)
+    sequence: int = pydantic.Field(exclude=True, default=0)
+    logins: typing.List[dict] = pydantic.Field(exclude=True, default_factory=list)
+    ready_received: bool = pydantic.Field(exclude=True, default=False)
+    heartbeat_task: typing.Optional[asyncio.Task] = pydantic.Field(exclude=True, default=None)
+    listeners: typing.Dict[typing.Type, typing.Callable] = pydantic.Field(
+        exclude=True, default_factory=dict
+    )
+
+    message_converter: SatoriMessageConverter = pydantic.Field(
+        default_factory=SatoriMessageConverter
+    )
+    event_converter: SatoriEventConverter = pydantic.Field(
+        default_factory=SatoriEventConverter
+    )
+
+    platform: str = pydantic.Field(exclude=True, default="llonebot")
+    host: str = pydantic.Field(exclude=True, default="127.0.0.1")
+    api_base_url: str = pydantic.Field(exclude=True, default="")
+    token: str = pydantic.Field(exclude=True, default="")
+    endpoint: str = pydantic.Field(exclude=True, default="")
+    port: int = pydantic.Field(exclude=True, default=5600)
+    auto_reconnect: bool = pydantic.Field(exclude=True, default=True)
+    heartbeat_interval: int = pydantic.Field(exclude=True, default=10)
+    reconnect_delay: int = pydantic.Field(exclude=True, default=5)
+
+    def __init__(
+        self,
+        config: dict,
+        logger: abstract_platform_logger.AbstractEventLogger,
+    ):
+        """Initialize Satori adapter"""
+        host = config.get("host", "127.0.0.1")
+        port = config.get("port", 5600)
+
+        # 初始化基类
+        super().__init__(
+            config=config,
+            logger=logger,
+            platform=config.get("platform", "llonebot"),
+            host=host,
+            api_base_url=config.get(
+                "satori_api_base_url",
+                f"http://{host}:{port}/v1"
+            ),
+            token=config.get("token", ""),
+            endpoint=config.get(
+                "satori_endpoint",
+                f"ws://{host}:{port}/v1/events"
+            ),
+            auto_reconnect=True,
+            port=port,
+            heartbeat_interval=10,
+            reconnect_delay=5,
+        )
+
+    def _is_websocket_closed(self, ws) -> bool:
+        """Check if WebSocket connection is closed"""
+        if not ws:
+            return True
+        try:
+            if hasattr(ws, "closed"):
+                return ws.closed
+            if hasattr(ws, "close_code"):
+                return ws.close_code is not None
+            return False
+        except AttributeError:
+            return True
+
+    async def run(self):
+        """Start the adapter"""
+        self.running = True
+        self.session = aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=30))
+
+        retry_count = 0
+        max_retries = 10
+
+        await self.logger.info(f"Satori 适配器启动中 - 连接到 {self.endpoint}")
+
+        while self.running:
+            try:
+                await self.connect_websocket()
+                retry_count = 0
+            except websockets.exceptions.ConnectionClosed as e:
+                await self.logger.warning(f"Satori WebSocket 连接关闭: {e}")
+                retry_count += 1
+            except Exception as e:
+                await self.logger.error(f"Satori WebSocket 连接失败: {e}")
+                retry_count += 1
+
+            if not self.running:
+                break
+
+            if retry_count >= max_retries:
+                await self.logger.error(f"达到最大重试次数 ({max_retries})，停止重试")
+                break
+
+            if not self.auto_reconnect:
+                break
+
+            delay = min(self.reconnect_delay * (2 ** (retry_count - 1)), 60)
+            await self.logger.info(f"{delay}秒后重新连接...")
+            await asyncio.sleep(delay)
+
+        if self.session:
+            await self.session.close()
+
+    async def connect_websocket(self):
+        """Connect to WebSocket"""
+        await self.logger.info(f"Satori 正在连接到 WebSocket: {self.endpoint}")
+        await self.logger.info(f"Satori HTTP API 地址: {self.api_base_url}")
+
+        if not self.endpoint.startswith(("ws://", "wss://")):
+            raise ValueError(f"WebSocket URL必须以ws://或wss://开头: {self.endpoint}")
+
+        try:
+            self.ws = await websockets.connect(self.endpoint)
+            await asyncio.sleep(0.1)
+
+            await self.send_identify()
+
+            self.heartbeat_task = asyncio.create_task(self.heartbeat_loop())
+
+            async for message in self.ws:
+                try:
+                    await self.handle_message(message)
+                except Exception as e:
+                    await self.logger.error(f"Satori 处理消息异常: {e}")
+
+        except websockets.exceptions.ConnectionClosed as e:
+            await self.logger.warning(f"Satori WebSocket 连接关闭: {e}")
+            raise
+        except Exception as e:
+            await self.logger.error(f"Satori WebSocket 连接异常: {e}")
+            raise
+        finally:
+            if self.heartbeat_task:
+                self.heartbeat_task.cancel()
+                try:
+                    await self.heartbeat_task
+                except asyncio.CancelledError:
+                    pass
+            if self.ws:
+                try:
+                    await self.ws.close()
+                except Exception as e:
+                    await self.logger.error(f"Satori WebSocket 关闭异常: {e}")
+
+    async def send_identify(self):
+        """Send IDENTIFY signal"""
+        if not self.ws:
+            raise Exception("WebSocket连接未建立")
+
+        if self._is_websocket_closed(self.ws):
+            raise Exception("WebSocket连接已关闭")
+
+        identify_payload = {
+            "op": 3,  # IDENTIFY
+            "body": {
+                "token": str(self.token) if self.token else "",
+            },
+        }
+
+        if self.sequence > 0:
+            identify_payload["body"]["sn"] = self.sequence
+
+        try:
+            message_str = json.dumps(identify_payload, ensure_ascii=False)
+            await self.ws.send(message_str)
+            await self.logger.info("Satori IDENTIFY 信令已发送")
+        except Exception as e:
+            await self.logger.error(f"发送 IDENTIFY 信令失败: {e}")
+            raise
+
+    async def heartbeat_loop(self):
+        """Heartbeat loop"""
+        try:
+            while self.running and self.ws:
+                await asyncio.sleep(self.heartbeat_interval)
+
+                if self.ws and not self._is_websocket_closed(self.ws):
+                    try:
+                        ping_payload = {
+                            "op": 1,  # PING
+                            "body": {},
+                        }
+                        await self.ws.send(json.dumps(ping_payload, ensure_ascii=False))
+                    except Exception as e:
+                        await self.logger.error(f"Satori WebSocket 发送心跳失败: {e}")
+                        break
+                else:
+                    break
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            await self.logger.error(f"心跳任务异常: {e}")
+
+    async def handle_message(self, message: str):
+        """Handle WebSocket message"""
+        try:
+            data = json.loads(message)
+            op = data.get("op")
+            body = data.get("body", {})
+
+            if op == 4:  # READY
+                self.logins = body.get("logins", [])
+                self.ready_received = True
+
+                if self.logins:
+                    for i, login in enumerate(self.logins):
+                        platform = login.get("platform", "")
+                        user = login.get("user", {})
+                        user_id = user.get("id", "")
+                        user_name = user.get("name", "")
+                        await self.logger.info(
+                            f"Satori 连接成功 - Bot {i + 1}: platform={platform}, user_id={user_id}, user_name={user_name}"
+                        )
+
+                if "sn" in body:
+                    self.sequence = body["sn"]
+
+            elif op == 2:  # PONG
+                pass
+
+            elif op == 0:  # EVENT
+                await self.handle_event(body)
+                if "sn" in body:
+                    self.sequence = body["sn"]
+
+            elif op == 5:  # META
+                if "sn" in body:
+                    self.sequence = body["sn"]
+
+        except json.JSONDecodeError as e:
+            await self.logger.error(f"解析 WebSocket 消息失败: {e}, 消息内容: {message}")
+        except Exception as e:
+            await self.logger.error(f"处理 WebSocket 消息异常: {e}")
+
+    async def handle_event(self, event_data: dict):
+        """Handle event"""
+        try:
+            event_type = event_data.get("type")
+
+            if event_type == "message-created":
+                message = event_data.get("message", {})
+                user = event_data.get("user", {})
+                channel = event_data.get("channel", {})
+                guild = event_data.get("guild")
+                login = event_data.get("login", {})
+
+                # Skip messages from self
+                bot_user_id = login.get("user", {}).get("id")
+                msg_user_id = user.get("id")
+                if bot_user_id and msg_user_id and str(bot_user_id) == str(msg_user_id):
+                    return
+
+                lb_event = await self.convert_satori_message(
+                    message, user, channel, guild, login
+                )
+                if lb_event and type(lb_event) in self.listeners:
+                    await self.listeners[type(lb_event)](lb_event, self)
+
+        except Exception as e:
+            await self.logger.error(f"处理事件失败: {e}\n{traceback.format_exc()}")
+
+    async def convert_satori_message(
+        self,
+        message: dict,
+        user: dict,
+        channel: dict,
+        guild: typing.Optional[dict],
+        login: dict,
+    ) -> typing.Optional[platform_events.MessageEvent]:
+        """Convert Satori message to LangBot event
+        
+        This is the main method for converting Satori messages to LangBot events.
+        It handles both private and group messages based on channel.type and guild info.
+        """
+        try:
+            # Extract basic info with type safety
+            user_id = str(user.get("id", "") or "")
+            user_name = str(user.get("name", "") or user.get("nick", "") or "")
+            message_id = str(message.get("id", "") or "")
+            message_content = str(message.get("content", "") or "")
+
+            # Log received message (truncate long content)
+            log_content = message_content[:100] + "..." if len(message_content) > 100 else message_content
+            await self.logger.info(f"Satori 消息接收: 用户ID={user_id}, 用户名={user_name}, 内容长度={len(message_content)}, 预览='{log_content}'")
+
+            # Convert message content
+            message_chain = await SatoriMessageConverter.target2yiri(
+                {"content": message_content}, self, ""
+            )
+
+            # Insert Source component at the beginning of the message chain
+            message_chain.insert(0, platform_message.Source(id=message_id, time=datetime.datetime.now()))
+
+            # Build original event object for source_platform_object
+            original_event = {
+                "type": "message-created",
+                "message": message,
+                "user": user,
+                "channel": channel,
+                "guild": guild,
+                "login": login,
+            }
+
+            # Try to get timestamp from message or use current time
+            msg_timestamp = message.get("timestamp") or message.get("created_at")
+            if msg_timestamp:
+                try:
+                    if isinstance(msg_timestamp, (int, float)):
+                        # Handle milliseconds vs seconds
+                        event_time = int(msg_timestamp) if msg_timestamp < 1e12 else int(msg_timestamp / 1000)
+                    else:
+                        # Try parsing ISO format
+                        event_time = int(datetime.datetime.fromisoformat(str(msg_timestamp).replace('Z', '+00:00')).timestamp())
+                except (ValueError, TypeError):
+                    event_time = int(time.time())
+            else:
+                event_time = int(time.time())
+
+            # Determine message type based on channel.type or guild presence
+            # In Satori protocol:
+            # - channel.type = 0: TEXT channel (group/guild message)
+            # - channel.type = 1: DIRECT channel (private message)
+            # Some implementations (like LLOneBot) may not provide guild info for group chats
+            channel_type = channel.get("type")
+            channel_id = str(channel.get("id", "") or "")
+
+            # Check if it's a private/direct message
+            # Private message: channel.type == 1, or no guild and no channel type (legacy)
+            is_private = (channel_type == 1)
+
+            # Check if it's a group message
+            # Group message: has guild info, or channel.type == 0
+            is_group = (guild and guild.get("id")) or (channel_type == 0)
+
+            await self.logger.info(f"Satori 消息类型判断: channel_type={channel_type}, channel_id={channel_id}, is_private={is_private}, is_group={is_group}, has_guild={guild is not None}")
+
+            if is_private:
+                # Private/friend message
+                sender = platform_entities.Friend(
+                    id=user_id,
+                    nickname=user_name,
+                    remark=user_name,
+                )
+                friend_message = platform_events.FriendMessage(
+                    message_chain=message_chain,
+                    sender=sender,
+                    time=event_time,
+                    source_platform_object=original_event,
+                )
+                await self.logger.info(f"Satori 私聊消息已构建: 用户ID={user_id}, 用户名={user_name}, 组件数={len(message_chain)}")
+                return friend_message
+            elif is_group:
+                # Group message
+                # Use guild.id if available, otherwise use channel.id as group_id
+                group_id = str(guild.get("id", "") or "") if guild and guild.get("id") else channel_id
+                group_name = str(guild.get("name", "Unknown Group") if guild else "Unknown Group")
+
+                group = platform_entities.Group(
+                    id=group_id,
+                    name=group_name,
+                    permission=platform_entities.Permission.Member
+                )
+                sender = platform_entities.GroupMember(
+                    id=user_id,
+                    member_name=user_name,
+                    permission=platform_entities.Permission.Member,
+                    group=group,
+                    special_title='',
+                )
+                group_message = platform_events.GroupMessage(
+                    message_chain=message_chain,
+                    sender=sender,
+                    time=event_time,
+                    source_platform_object=original_event,
+                )
+                await self.logger.info(f"Satori 群消息已构建: 群ID={group_id}, 发送者={user_name}, 组件数={len(message_chain)}")
+                return group_message
+            else:
+                # Fallback: treat as private message if cannot determine type
+                await self.logger.warning(f"Satori 无法确定消息类型，使用私聊作为fallback: channel_type={channel_type}")
+                sender = platform_entities.Friend(
+                    id=user_id,
+                    nickname=user_name,
+                    remark=user_name,
+                )
+                friend_message = platform_events.FriendMessage(
+                    message_chain=message_chain,
+                    sender=sender,
+                    time=event_time,
+                    source_platform_object=original_event,
+                )
+                await self.logger.info(f"Satori 私聊消息已构建 (fallback): 用户ID={user_id}, 用户名={user_name}")
+                return friend_message
+
+        except Exception as e:
+            await self.logger.error(f"转换 Satori 消息失败: {e}\n{traceback.format_exc()}")
+            return None
+
+
+
+    async def send_http_request(
+        self,
+        method: str,
+        path: str,
+        data: typing.Optional[dict] = None,
+        platform: typing.Optional[str] = None,
+        user_id: typing.Optional[str] = None,
+    ) -> typing.Optional[dict]:
+        """Send HTTP request to Satori API"""
+        if not self.session:
+            await self.logger.error("HTTP session 未初始化")
+            return None
+
+        url = f"{self.api_base_url}{path}"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.token}",
+        }
+
+        if platform:
+            headers["Satori-Platform"] = platform
+        if user_id:
+            headers["Satori-User-ID"] = user_id
+
+        try:
+            async with self.session.request(
+                method, url, headers=headers, json=data
+            ) as response:
+                if response.status == 200:
+                    return await response.json()
+                else:
+                    text = await response.text()
+                    await self.logger.error(f"Satori API 请求失败: {response.status} - {text}")
+                    return None
+        except Exception as e:
+            await self.logger.error(f"Satori API 请求异常: {e}")
+            return None
+
+    async def upload_image(
+        self,
+        image_bytes: bytes,
+        mime_type: str = "image/png",
+    ) -> typing.Optional[str]:
+        """Upload image to Satori server and return the URL
+        
+        Uses multipart/form-data to upload the image file via upload.create API.
+        Returns the URL of the uploaded image, or None if upload fails.
+        """
+        if not self.session:
+            await self.logger.error("HTTP session 未初始化")
+            return None
+
+        url = f"{self.api_base_url}/upload.create"
+        headers = {}
+        
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+
+        platform = ""
+        user_id = ""
+        if self.logins:
+            current_login = self.logins[0]
+            platform = current_login.get("platform", "")
+            user = current_login.get("user", {})
+            user_id = user.get("id", "")
+
+        if platform:
+            headers["Satori-Platform"] = platform
+        if user_id:
+            headers["Satori-User-ID"] = user_id
+
+        try:
+            # Determine file extension from mime type
+            ext = "png"
+            if "jpeg" in mime_type or "jpg" in mime_type:
+                ext = "jpg"
+            elif "gif" in mime_type:
+                ext = "gif"
+            elif "webp" in mime_type:
+                ext = "webp"
+            
+            # Create multipart form data
+            form_data = aiohttp.FormData()
+            form_data.add_field(
+                'file',
+                image_bytes,
+                filename=f'image.{ext}',
+                content_type=mime_type
+            )
+
+            async with self.session.post(
+                url, headers=headers, data=form_data
+            ) as response:
+                if response.status == 200:
+                    result = await response.json()
+                    # The response should contain the URL of the uploaded file
+                    if isinstance(result, dict) and 'url' in result:
+                        return result['url']
+                    elif isinstance(result, list) and len(result) > 0 and 'url' in result[0]:
+                        return result[0]['url']
+                    else:
+                        await self.logger.warning(f"Satori 图片上传响应格式未知: {result}")
+                        return None
+                else:
+                    text = await response.text()
+                    await self.logger.error(f"Satori 图片上传失败: {response.status} - {text}")
+                    return None
+        except Exception as e:
+            await self.logger.error(f"Satori 图片上传异常: {e}")
+            return None
+
+    async def kill(self) -> bool:
+        """Stop the adapter"""
+        self.running = False
+        if self.heartbeat_task:
+            self.heartbeat_task.cancel()
+        if self.ws:
+            try:
+                await self.ws.close()
+            except Exception:
+                pass
+        if self.session:
+            await self.session.close()
+        await self.logger.info("Satori 适配器已停止")
+        return True
+
+    async def send_message(
+        self,
+        target_type: str,
+        target_id: str,
+        message: platform_message.MessageChain,
+    ):
+        """Send message"""
+        try:
+            content = await self.message_converter.yiri2target(message, self)
+
+            platform = ""
+            user_id = ""
+            if self.logins:
+                current_login = self.logins[0]
+                platform = current_login.get("platform", "")
+                user = current_login.get("user", {})
+                user_id = user.get("id", "")
+
+            data = {"channel_id": target_id, "content": content}
+            await self.send_http_request(
+                "POST", "/message.create", data, platform, user_id
+            )
+
+        except Exception as e:
+            await self.logger.error(f"Satori 发送消息失败: {e}")
+
+    async def reply_message(
+        self,
+        message_source: platform_events.MessageEvent,
+        message: platform_message.MessageChain,
+        quote_origin: bool = False,
+    ):
+        """Reply to message"""
+        try:
+            content = await self.message_converter.yiri2target(message, self)
+
+            # Try to get channel_id from source_platform_object first (Satori protocol needs original channel.id)
+            channel_id = ""
+            if hasattr(message_source, 'source_platform_object') and message_source.source_platform_object:
+                source_obj = message_source.source_platform_object
+                if isinstance(source_obj, dict):
+                    channel = source_obj.get("channel", {})
+                    if channel and channel.get("id"):
+                        channel_id = str(channel.get("id"))
+
+            # Fallback: get channel_id from message source
+            if not channel_id:
+                if isinstance(message_source, platform_events.GroupMessage):
+                    # Group message: use group ID
+                    if hasattr(message_source.sender, "group") and hasattr(message_source.sender.group, "id"):
+                        channel_id = message_source.sender.group.id
+                elif isinstance(message_source, platform_events.FriendMessage):
+                    # Private message: use sender ID as channel_id
+                    if hasattr(message_source.sender, "id"):
+                        channel_id = message_source.sender.id
+
+            # Last fallback
+            if not channel_id:
+                if hasattr(message_source, "sender") and hasattr(message_source.sender, "id"):
+                    channel_id = message_source.sender.id
+
+            if not channel_id:
+                await self.logger.error("无法获取频道ID")
+                return
+
+            platform = ""
+            user_id = ""
+            if self.logins:
+                current_login = self.logins[0]
+                platform = current_login.get("platform", "")
+                user = current_login.get("user", {})
+                user_id = user.get("id", "")
+
+            data = {"channel_id": channel_id, "content": content}
+            await self.send_http_request(
+                "POST", "/message.create", data, platform, user_id
+            )
+
+        except Exception as e:
+            await self.logger.error(f"Satori 回复消息失败: {e}")
+
+    async def is_muted(self, group_id: int) -> bool:
+        """Check if the bot is muted in a group"""
+        return False
+
+    def register_listener(
+        self,
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[
+            [platform_events.Event, abstract_platform_adapter.AbstractMessagePlatformAdapter], None
+        ],
+    ):
+        """Register an event listener"""
+        self.listeners[event_type] = callback
+
+    def unregister_listener(
+        self,
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[
+            [platform_events.Event, abstract_platform_adapter.AbstractMessagePlatformAdapter], None
+        ],
+    ):
+        """Unregister an event listener"""
+        if event_type in self.listeners:
+            del self.listeners[event_type]
+
+    async def run_async(self):
+        """Async run wrapper"""
+        await self.run()
diff --git a/src/langbot/pkg/platform/sources/satori.yaml b/src/langbot/pkg/platform/sources/satori.yaml
new file mode 100644
index 00000000..325bbd22
--- /dev/null
+++ b/src/langbot/pkg/platform/sources/satori.yaml
@@ -0,0 +1,65 @@
+apiVersion: v1
+kind: MessagePlatformAdapter
+metadata:
+  name: satori
+  label:
+    en_US: Satori
+    zh_Hans: Satori
+  description:
+    en_US: SatoriAdapter
+    zh_Hans: 古明地觉协议适配器
+  icon: satori.png
+spec:
+  config:
+    - name: platform
+      label:
+        en_US: Platform
+        zh_Hans: 平台名称
+      type: string
+      required: true
+      default: "llonebot"
+      description:
+        en_US: The platform name (e.g., llonebot, discord, telegram)
+        zh_Hans: 平台名称（如 llonebot, discord, telegram）
+    - name: host
+      label:
+        en_US: Host
+        zh_Hans: 主机地址
+      type: string
+      required: true
+      default: "127.0.0.1"
+      description:
+        en_US: The host address of LLOneBot Satori server (e.g., 127.0.0.1, localhost, 192.168.1.100)
+        zh_Hans: LLOneBot Satori服务器的主机地址（如 127.0.0.1, localhost, 192.168.1.100）
+    - name: port
+      label:
+        en_US: Port
+        zh_Hans: 监听端口
+      type: int
+      required: true
+      default: 5600
+    - name: satori_api_base_url
+      label:
+        en_US: Satori API Endpoint
+        zh_Hans: Satori API 终结点
+      type: string
+      required: true
+      default: "http://localhost:5600/v1"
+    - name: satori_endpoint
+      label:
+        en_US: Satori WebSocket Endpoint
+        zh_Hans: Satori WebSocket 终结点
+      type: string
+      required: true
+      default: "ws://localhost:5600/v1/events"
+    - name: token
+      label:
+        en_US: Token
+        zh_Hans: 令牌
+      type: string
+      required: true
+      default: ""
+execution:
+  python:
+    path: ./satori.py
+    attr: SatoriAdapter
\ No newline at end of file