AstrBot 4.7.3__py3-none-any.whl → 4.8.0__py3-none-any.whl

astrbot/core/platform/manager.py

@@ -6,7 +6,7 @@ from astrbot.core import logger
 from astrbot.core.config.astrbot_config import AstrBotConfig
 from astrbot.core.star.star_handler import EventType, star_handlers_registry, star_map
 
-from .platform import Platform
+from .platform import Platform, PlatformStatus
 from .register import platform_cls_map
 from .sources.webchat.webchat_adapter import WebChatAdapter
 
@@ -16,7 +16,7 @@ class PlatformManager:
         self.platform_insts: list[Platform] = []
         """加载的 Platform 的实例"""
 
-        self._inst_map = {}
+        self._inst_map: dict[str, dict] = {}
 
         self.platforms_config = config["platform"]
         self.settings = config["platform_settings"]
@@ -37,7 +37,10 @@ class PlatformManager:
         webchat_inst = WebChatAdapter({}, self.settings, self.event_queue)
         self.platform_insts.append(webchat_inst)
         asyncio.create_task(
-            self._task_wrapper(asyncio.create_task(webchat_inst.run(), name="webchat")),
+            self._task_wrapper(
+                asyncio.create_task(webchat_inst.run(), name="webchat"),
+                platform=webchat_inst,
+            ),
         )
 
     async def load_platform(self, platform_config: dict):
@@ -107,7 +110,7 @@ class PlatformManager:
                     )
         except (ImportError, ModuleNotFoundError) as e:
             logger.error(
-                f"加载平台适配器 {platform_config['type']} 失败，原因：{e}。请检查依赖库是否安装。提示：可以在 管理面板->控制台->安装Pip库 中安装依赖库。",
+                f"加载平台适配器 {platform_config['type']} 失败，原因：{e}。请检查依赖库是否安装。提示：可以在 管理面板->平台日志->安装Pip库 中安装依赖库。",
             )
         except Exception as e:
             logger.error(f"加载平台适配器 {platform_config['type']} 失败，原因：{e}。")
@@ -131,6 +134,7 @@ class PlatformManager:
                     inst.run(),
                     name=f"platform_{platform_config['type']}_{platform_config['id']}",
                 ),
+                platform=inst,
             ),
         )
         handlers = star_handlers_registry.get_handlers_by_event_type(
@@ -145,17 +149,28 @@ class PlatformManager:
             except Exception:
                 logger.error(traceback.format_exc())
 
-    async def _task_wrapper(self, task: asyncio.Task):
+    async def _task_wrapper(self, task: asyncio.Task, platform: Platform | None = None):
+        # 设置平台状态为运行中
+        if platform:
+            platform.status = PlatformStatus.RUNNING
+
         try:
             await task
         except asyncio.CancelledError:
-            pass
+            if platform:
+                platform.status = PlatformStatus.STOPPED
         except Exception as e:
+            error_msg = str(e)
+            tb_str = traceback.format_exc()
             logger.error(f"------- 任务 {task.get_name()} 发生错误: {e}")
-            for line in traceback.format_exc().split("\n"):
+            for line in tb_str.split("\n"):
                 logger.error(f"|    {line}")
             logger.error("-------")
 
+            # 记录错误到平台实例
+            if platform:
+                platform.record_error(error_msg, tb_str)
+
     async def reload(self, platform_config: dict):
         await self.terminate_platform(platform_config["id"])
         if platform_config["enable"]:
@@ -172,9 +187,9 @@ class PlatformManager:
             logger.info(f"正在尝试终止 {platform_id} 平台适配器 ...")
 
             # client_id = self._inst_map.pop(platform_id, None)
-            info = self._inst_map.pop(platform_id, None)
+            info = self._inst_map.pop(platform_id)
             client_id = info["client_id"]
-            inst = info["inst"]
+            inst: Platform = info["inst"]
             try:
                 self.platform_insts.remove(
                     next(
@@ -196,3 +211,46 @@ class PlatformManager:
 
     def get_insts(self):
         return self.platform_insts
+
+    def get_all_stats(self) -> dict:
+        """获取所有平台的统计信息
+
+        Returns:
+            包含所有平台统计信息的字典
+        """
+        stats_list = []
+        total_errors = 0
+        running_count = 0
+        error_count = 0
+
+        for inst in self.platform_insts:
+            try:
+                stat = inst.get_stats()
+                stats_list.append(stat)
+                total_errors += stat.get("error_count", 0)
+                if stat.get("status") == PlatformStatus.RUNNING.value:
+                    running_count += 1
+                elif stat.get("status") == PlatformStatus.ERROR.value:
+                    error_count += 1
+            except Exception as e:
+                # 如果获取统计信息失败，记录基本信息
+                logger.warning(f"获取平台统计信息失败: {e}")
+                stats_list.append(
+                    {
+                        "id": getattr(inst, "config", {}).get("id", "unknown"),
+                        "type": "unknown",
+                        "status": "unknown",
+                        "error_count": 0,
+                        "last_error": None,
+                    }
+                )
+
+        return {
+            "platforms": stats_list,
+            "summary": {
+                "total": len(stats_list),
+                "running": running_count,
+                "error": error_count,
+                "total_errors": total_errors,
+            },
+        }

astrbot/core/platform/platform.py

@@ -2,6 +2,9 @@ import abc
 import uuid
 from asyncio import Queue
 from collections.abc import Awaitable
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
 from typing import Any
 
 from astrbot.core.message.message_event_result import MessageChain
@@ -12,13 +15,90 @@ from .message_session import MessageSesion
 from .platform_metadata import PlatformMetadata
 
 
+class PlatformStatus(Enum):
+    """平台运行状态"""
+
+    PENDING = "pending"  # 待启动
+    RUNNING = "running"  # 运行中
+    ERROR = "error"  # 发生错误
+    STOPPED = "stopped"  # 已停止
+
+
+@dataclass
+class PlatformError:
+    """平台错误信息"""
+
+    message: str
+    timestamp: datetime = field(default_factory=datetime.now)
+    traceback: str | None = None
+
+
 class Platform(abc.ABC):
-    def __init__(self, event_queue: Queue):
+    def __init__(self, config: dict, event_queue: Queue):
         super().__init__()
+        # 平台配置
+        self.config = config
         # 维护了消息平台的事件队列，EventBus 会从这里取出事件并处理。
         self._event_queue = event_queue
         self.client_self_id = uuid.uuid4().hex
 
+        # 平台运行状态
+        self._status: PlatformStatus = PlatformStatus.PENDING
+        self._errors: list[PlatformError] = []
+        self._started_at: datetime | None = None
+
+    @property
+    def status(self) -> PlatformStatus:
+        """获取平台运行状态"""
+        return self._status
+
+    @status.setter
+    def status(self, value: PlatformStatus):
+        """设置平台运行状态"""
+        self._status = value
+        if value == PlatformStatus.RUNNING and self._started_at is None:
+            self._started_at = datetime.now()
+
+    @property
+    def errors(self) -> list[PlatformError]:
+        """获取错误列表"""
+        return self._errors
+
+    @property
+    def last_error(self) -> PlatformError | None:
+        """获取最近的错误"""
+        return self._errors[-1] if self._errors else None
+
+    def record_error(self, message: str, traceback_str: str | None = None):
+        """记录一个错误"""
+        self._errors.append(PlatformError(message=message, traceback=traceback_str))
+        self._status = PlatformStatus.ERROR
+
+    def clear_errors(self):
+        """清除错误记录"""
+        self._errors.clear()
+        if self._status == PlatformStatus.ERROR:
+            self._status = PlatformStatus.RUNNING
+
+    def get_stats(self) -> dict:
+        """获取平台统计信息"""
+        meta = self.meta()
+        return {
+            "id": meta.id or self.config.get("id"),
+            "type": meta.name,
+            "display_name": meta.adapter_display_name or meta.name,
+            "status": self._status.value,
+            "started_at": self._started_at.isoformat() if self._started_at else None,
+            "error_count": len(self._errors),
+            "last_error": {
+                "message": self.last_error.message,
+                "timestamp": self.last_error.timestamp.isoformat(),
+                "traceback": self.last_error.traceback,
+            }
+            if self.last_error
+            else None,
+        }
+
     @abc.abstractmethod
     def run(self) -> Awaitable[Any]:
         """得到一个平台的运行实例，需要返回一个协程对象。"""
@@ -36,7 +116,7 @@ class Platform(abc.ABC):
         self,
         session: MessageSesion,
         message_chain: MessageChain,
-    ) -> Awaitable[Any]:
+    ):
         """通过会话发送消息。该方法旨在让插件能够直接通过**可持久化的会话数据**发送消息，而不需要保存 event 对象。
 
         异步方法。
@@ -49,3 +129,20 @@ class Platform(abc.ABC):
 
     def get_client(self):
         """获取平台的客户端对象。"""
+
+    async def webhook_callback(self, request: Any) -> Any:
+        """统一 Webhook 回调入口。
+
+        支持统一 Webhook 模式的平台需要实现此方法。
+        当 Dashboard 收到 /api/platform/webhook/{uuid} 请求时，会调用此方法。
+
+        Args:
+            request: Quart 请求对象
+
+        Returns:
+            响应内容，格式取决于具体平台的要求
+
+        Raises:
+            NotImplementedError: 平台未实现统一 Webhook 模式
+        """
+        raise NotImplementedError(f"平台 {self.meta().name} 未实现统一 Webhook 模式")

astrbot/core/platform/sources/aiocqhttp/aiocqhttp_platform_adapter.py

@@ -38,9 +38,8 @@ class AiocqhttpAdapter(Platform):
         platform_settings: dict,
         event_queue: asyncio.Queue,
     ) -> None:
-        super().__init__(event_queue)
+        super().__init__(platform_config, event_queue)
 
-        self.config = platform_config
         self.settings = platform_settings
         self.unique_session = platform_settings["unique_session"]
         self.host = platform_config["ws_reverse_host"]
@@ -154,7 +153,9 @@ class AiocqhttpAdapter(Platform):
         """OneBot V11 通知类事件"""
         abm = AstrBotMessage()
         abm.self_id = str(event.self_id)
-        abm.sender = MessageMember(user_id=str(event.user_id), nickname=event.user_id)
+        abm.sender = MessageMember(
+            user_id=str(event.user_id), nickname=str(event.user_id)
+        )
         abm.type = MessageType.OTHER_MESSAGE
         if event.get("group_id"):
             abm.group_id = str(event.group_id)
@@ -246,7 +247,13 @@ class AiocqhttpAdapter(Platform):
                     if m["data"].get("url") and m["data"].get("url").startswith("http"):
                         # Lagrange
                         logger.info("guessing lagrange")
-                        file_name = m["data"].get("file_name", "file")
+                        # 检查多个可能的文件名字段
+                        file_name = (
+                            m["data"].get("file_name", "")
+                            or m["data"].get("name", "")
+                            or m["data"].get("file", "")
+                            or "file"
+                        )
                         abm.message.append(File(name=file_name, url=m["data"]["url"]))
                     else:
                         try:
@@ -265,7 +272,14 @@ class AiocqhttpAdapter(Platform):
                                 )
                             if ret and "url" in ret:
                                 file_url = ret["url"]  # https
-                                a = File(name="", url=file_url)
+                                # 优先从 API 返回值获取文件名，其次从原始消息数据获取
+                                file_name = (
+                                    ret.get("file_name", "")
+                                    or ret.get("name", "")
+                                    or m["data"].get("file", "")
+                                    or m["data"].get("file_name", "")
+                                )
+                                a = File(name=file_name, url=file_url)
                                 abm.message.append(a)
                             else:
                                 logger.error(f"获取文件失败: {ret}")

astrbot/core/platform/sources/dingtalk/dingtalk_adapter.py

@@ -47,9 +47,7 @@ class DingtalkPlatformAdapter(Platform):
         platform_settings: dict,
         event_queue: asyncio.Queue,
     ) -> None:
-        super().__init__(event_queue)
-
-        self.config = platform_config
+        super().__init__(platform_config, event_queue)
 
         self.unique_session = platform_settings["unique_session"]
 
@@ -76,13 +74,13 @@ class DingtalkPlatformAdapter(Platform):
         )
         self.client_ = client  # 用于 websockets 的 client
 
-    def _id_to_sid(self, dingtalk_id: str | None) -> str | None:
+    def _id_to_sid(self, dingtalk_id: str | None) -> str:
         if not dingtalk_id:
-            return dingtalk_id
+            return dingtalk_id or "unknown"
         prefix = "$:LWCP_v1:$"
         if dingtalk_id.startswith(prefix):
             return dingtalk_id[len(prefix) :]
-        return dingtalk_id
+        return dingtalk_id or "unknown"
 
     async def send_by_session(
         self,
@@ -250,7 +248,7 @@ class DingtalkPlatformAdapter(Platform):
 
     async def terminate(self):
         def monkey_patch_close():
-            raise Exception("Graceful shutdown")
+            raise KeyboardInterrupt("Graceful shutdown")
 
         self.client_.open_connection = monkey_patch_close
         await self.client_.websocket.close(code=1000, reason="Graceful shutdown")

astrbot/core/platform/sources/discord/discord_platform_adapter.py

@@ -44,8 +44,7 @@ class DiscordPlatformAdapter(Platform):
         platform_settings: dict,
         event_queue: asyncio.Queue,
     ) -> None:
-        super().__init__(event_queue)
-        self.config = platform_config
+        super().__init__(platform_config, event_queue)
         self.settings = platform_settings
         self.client_self_id = None
         self.registered_handlers = []

astrbot/core/platform/sources/lark/lark_adapter.py

@@ -33,9 +33,7 @@ class LarkPlatformAdapter(Platform):
         platform_settings: dict,
         event_queue: asyncio.Queue,
     ) -> None:
-        super().__init__(event_queue)
-
-        self.config = platform_config
+        super().__init__(platform_config, event_queue)
 
         self.unique_session = platform_settings["unique_session"]
 

astrbot/core/platform/sources/misskey/misskey_adapter.py

@@ -55,8 +55,7 @@ class MisskeyPlatformAdapter(Platform):
         platform_settings: dict,
         event_queue: asyncio.Queue,
     ) -> None:
-        super().__init__(event_queue)
-        self.config = platform_config or {}
+        super().__init__(platform_config or {}, event_queue)
         self.settings = platform_settings or {}
         self.instance_url = self.config.get("misskey_instance_url", "")
         self.access_token = self.config.get("misskey_token", "")

astrbot/core/platform/sources/qqofficial/qqofficial_message_event.py

@@ -69,6 +69,8 @@ class QQOfficialMessageEvent(AstrMessageEvent):
                 # 结束流式对话，并且传输 buffer 中剩余的消息
                 stream_payload["state"] = 10
                 ret = await self._post_send(stream=stream_payload)
+            else:
+                ret = await self._post_send()
 
         except Exception as e:
             logger.error(f"发送流式消息时出错: {e}", exc_info=True)

astrbot/core/platform/sources/qqofficial/qqofficial_platform_adapter.py

@@ -97,9 +97,7 @@ class QQOfficialPlatformAdapter(Platform):
         platform_settings: dict,
         event_queue: asyncio.Queue,
     ) -> None:
-        super().__init__(event_queue)
-
-        self.config = platform_config
+        super().__init__(platform_config, event_queue)
 
         self.appid = platform_config["appid"]
         self.secret = platform_config["secret"]

astrbot/core/platform/sources/qqofficial_webhook/qo_webhook_adapter.py

@@ -1,5 +1,6 @@
 import asyncio
 import logging
+from typing import Any
 
 import botpy
 import botpy.message
@@ -11,6 +12,7 @@ from astrbot import logger
 from astrbot.api.event import MessageChain
 from astrbot.api.platform import AstrBotMessage, MessageType, Platform, PlatformMetadata
 from astrbot.core.platform.astr_message_event import MessageSesion
+from astrbot.core.utils.webhook_utils import log_webhook_info
 
 from ...register import register_platform_adapter
 from ..qqofficial.qqofficial_platform_adapter import QQOfficialPlatformAdapter
@@ -87,13 +89,12 @@ class QQOfficialWebhookPlatformAdapter(Platform):
         platform_settings: dict,
         event_queue: asyncio.Queue,
     ) -> None:
-        super().__init__(event_queue)
-
-        self.config = platform_config
+        super().__init__(platform_config, event_queue)
 
         self.appid = platform_config["appid"]
         self.secret = platform_config["secret"]
         self.unique_session = platform_settings["unique_session"]
+        self.unified_webhook_mode = platform_config.get("unified_webhook_mode", False)
 
         intents = botpy.Intents(
             public_messages=True,
@@ -106,6 +107,7 @@ class QQOfficialWebhookPlatformAdapter(Platform):
             timeout=20,
         )
         self.client.set_platform(self)
+        self.webhook_helper = None
 
     async def send_by_session(
         self,
@@ -128,16 +130,37 @@ class QQOfficialWebhookPlatformAdapter(Platform):
             self.client,
         )
         await self.webhook_helper.initialize()
-        await self.webhook_helper.start_polling()
+
+        # 如果启用统一 webhook 模式，则不启动独立服务器
+        webhook_uuid = self.config.get("webhook_uuid")
+        if self.unified_webhook_mode and webhook_uuid:
+            log_webhook_info(f"{self.meta().id}(QQ 官方机器人 Webhook)", webhook_uuid)
+            # 保持运行状态，等待 shutdown
+            await self.webhook_helper.shutdown_event.wait()
+        else:
+            await self.webhook_helper.start_polling()
 
     def get_client(self) -> botClient:
         return self.client
 
+    async def webhook_callback(self, request: Any) -> Any:
+        """统一 Webhook 回调入口"""
+        if not self.webhook_helper:
+            return {"error": "Webhook helper not initialized"}, 500
+
+        # 复用 webhook_helper 的回调处理逻辑
+        return await self.webhook_helper.handle_callback(request)
+
     async def terminate(self):
-        self.webhook_helper.shutdown_event.set()
+        if self.webhook_helper:
+            self.webhook_helper.shutdown_event.set()
         await self.client.close()
-        try:
-            await self.webhook_helper.server.shutdown()
-        except Exception as _:
-            pass
+        if self.webhook_helper and not self.unified_webhook_mode:
+            try:
+                await self.webhook_helper.server.shutdown()
+            except Exception as exc:
+                logger.warning(
+                    f"Exception occurred during QQOfficialWebhook server shutdown: {exc}",
+                    exc_info=True,
+                )
         logger.info("QQ 机器人官方 API 适配器已经被优雅地关闭")

astrbot/core/platform/sources/qqofficial_webhook/qo_webhook_server.py

@@ -78,7 +78,19 @@ class QQOfficialWebhook:
         return response
 
     async def callback(self):
-        msg: dict = await quart.request.json
+        """内部服务器的回调入口"""
+        return await self.handle_callback(quart.request)
+
+    async def handle_callback(self, request) -> dict:
+        """处理 webhook 回调，可被统一 webhook 入口复用
+
+        Args:
+            request: Quart 请求对象
+
+        Returns:
+            响应数据
+        """
+        msg: dict = await request.json
         logger.debug(f"收到 qq_official_webhook 回调: {msg}")
 
         event = msg.get("t")

astrbot/core/platform/sources/satori/satori_adapter.py

@@ -38,8 +38,7 @@ class SatoriPlatformAdapter(Platform):
         platform_settings: dict,
         event_queue: asyncio.Queue,
     ) -> None:
-        super().__init__(event_queue)
-        self.config = platform_config
+        super().__init__(platform_config, event_queue)
         self.settings = platform_settings
 
         self.api_base_url = self.config.get(

astrbot/core/platform/sources/slack/client.py

@@ -47,51 +47,62 @@ class SlackWebhookClient:
 
         @self.app.route(self.path, methods=["POST"])
         async def slack_events():
-            """处理 Slack 事件"""
-            try:
-                # 获取请求体和头部
-                body = await request.get_data()
-                event_data = json.loads(body.decode("utf-8"))
-
-                # Verify Slack request signature
-                timestamp = request.headers.get("X-Slack-Request-Timestamp")
-                signature = request.headers.get("X-Slack-Signature")
-                if not timestamp or not signature:
-                    return Response("Missing headers", status=400)
-                # Calculate the HMAC signature
-                sig_basestring = f"v0:{timestamp}:{body.decode('utf-8')}"
-                my_signature = (
-                    "v0="
-                    + hmac.new(
-                        self.signing_secret.encode("utf-8"),
-                        sig_basestring.encode("utf-8"),
-                        hashlib.sha256,
-                    ).hexdigest()
-                )
-                # Verify the signature
-                if not hmac.compare_digest(my_signature, signature):
-                    logger.warning("Slack request signature verification failed")
-                    return Response("Invalid signature", status=400)
-                logger.info(f"Received Slack event: {event_data}")
-
-                # 处理 URL 验证事件
-                if event_data.get("type") == "url_verification":
-                    return {"challenge": event_data.get("challenge")}
-                # 处理事件
-                if self.event_handler and event_data.get("type") == "event_callback":
-                    await self.event_handler(event_data)
-
-                return Response("", status=200)
-
-            except Exception as e:
-                logger.error(f"处理 Slack 事件时出错: {e}")
-                return Response("Internal Server Error", status=500)
+            """内部服务器的 POST 回调入口"""
+            return await self.handle_callback(request)
 
         @self.app.route("/health", methods=["GET"])
         async def health_check():
             """健康检查端点"""
             return {"status": "ok", "service": "slack-webhook"}
 
+    async def handle_callback(self, req):
+        """处理 Slack 回调请求，可被统一 webhook 入口复用
+
+        Args:
+            req: Quart 请求对象
+
+        Returns:
+            Response 对象或字典
+        """
+        try:
+            # 获取请求体和头部
+            body = await req.get_data()
+            event_data = json.loads(body.decode("utf-8"))
+
+            # Verify Slack request signature
+            timestamp = req.headers.get("X-Slack-Request-Timestamp")
+            signature = req.headers.get("X-Slack-Signature")
+            if not timestamp or not signature:
+                return Response("Missing headers", status=400)
+            # Calculate the HMAC signature
+            sig_basestring = f"v0:{timestamp}:{body.decode('utf-8')}"
+            my_signature = (
+                "v0="
+                + hmac.new(
+                    self.signing_secret.encode("utf-8"),
+                    sig_basestring.encode("utf-8"),
+                    hashlib.sha256,
+                ).hexdigest()
+            )
+            # Verify the signature
+            if not hmac.compare_digest(my_signature, signature):
+                logger.warning("Slack request signature verification failed")
+                return Response("Invalid signature", status=400)
+            logger.info(f"Received Slack event: {event_data}")
+
+            # 处理 URL 验证事件
+            if event_data.get("type") == "url_verification":
+                return {"challenge": event_data.get("challenge")}
+            # 处理事件
+            if self.event_handler and event_data.get("type") == "event_callback":
+                await self.event_handler(event_data)
+
+            return Response("", status=200)
+
+        except Exception as e:
+            logger.error(f"处理 Slack 事件时出错: {e}")
+            return Response("Internal Server Error", status=500)
+
     async def start(self):
         """启动 Webhook 服务器"""
         logger.info(