AstrBot 4.7.4__py3-none-any.whl → 4.9.0__py3-none-any.whl

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

@@ -1,5 +1,6 @@
 import asyncio
 import logging
+from typing import Any, cast
 
 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
@@ -34,7 +36,9 @@ class botClient(Client):
             MessageType.GROUP_MESSAGE,
         )
         abm.session_id = (
-            abm.sender.user_id if self.platform.unique_session else message.group_openid
+            abm.sender.user_id
+            if self.platform.unique_session
+            else cast(str, message.group_openid)
         )
         self._commit(abm)
 
@@ -87,13 +91,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 +109,7 @@ class QQOfficialWebhookPlatformAdapter(Platform):
             timeout=20,
         )
         self.client.set_platform(self)
+        self.webhook_helper = None
 
     async def send_by_session(
         self,
@@ -118,7 +122,7 @@ class QQOfficialWebhookPlatformAdapter(Platform):
         return PlatformMetadata(
             name="qq_official_webhook",
             description="QQ 机器人官方 API 适配器",
-            id=self.config.get("id"),
+            id=cast(str, self.config.get("id")),
         )
 
     async def run(self):
@@ -128,16 +132,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

@@ -1,5 +1,6 @@
 import asyncio
 import logging
+from typing import cast
 
 import quart
 from botpy import BotAPI, BotHttp, BotWebSocket, Client, ConnectionSession, Token
@@ -78,7 +79,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")
@@ -87,7 +100,7 @@ class QQOfficialWebhook:
 
         if opcode == 13:
             # validation
-            signed = await self.webhook_validation(data)
+            signed = await self.webhook_validation(cast(dict, data))
             print(signed)
             return signed
 

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

@@ -4,9 +4,11 @@ import hmac
 import json
 import logging
 from collections.abc import Callable
+from typing import cast
 
 from quart import Quart, Response, request
 from slack_sdk.socket_mode.aiohttp import SocketModeClient
+from slack_sdk.socket_mode.async_client import AsyncBaseSocketModeClient
 from slack_sdk.socket_mode.request import SocketModeRequest
 from slack_sdk.socket_mode.response import SocketModeResponse
 from slack_sdk.web.async_client import AsyncWebClient
@@ -47,51 +49,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 = cast(bytes, 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(
@@ -128,9 +141,14 @@ class SlackSocketClient:
         self.event_handler = event_handler
         self.socket_client = None
 
-    async def _handle_events(self, _: SocketModeClient, req: SocketModeRequest):
+    async def _handle_events(
+        self, _: AsyncBaseSocketModeClient, req: SocketModeRequest
+    ):
         """处理 Socket Mode 事件"""
         try:
+            if self.socket_client is None:
+                raise RuntimeError("Socket client is not initialized")
+
             # 确认收到事件
             response = SocketModeResponse(envelope_id=req.envelope_id)
             await self.socket_client.send_socket_mode_response(response)

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

@@ -3,8 +3,7 @@ import base64
 import re
 import time
 import uuid
-from collections.abc import Awaitable
-from typing import Any
+from typing import Any, cast
 
 import aiohttp
 from slack_sdk.socket_mode.request import SocketModeRequest
@@ -21,6 +20,7 @@ from astrbot.api.platform import (
     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 .client import SlackSocketClient, SlackWebhookClient
@@ -39,9 +39,7 @@ class SlackAdapter(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.unique_session = platform_settings.get("unique_session", False)
 
@@ -49,6 +47,7 @@ class SlackAdapter(Platform):
         self.app_token = platform_config.get("app_token")
         self.signing_secret = platform_config.get("signing_secret")
         self.connection_mode = platform_config.get("slack_connection_mode", "socket")
+        self.unified_webhook_mode = platform_config.get("unified_webhook_mode", False)
         self.webhook_host = platform_config.get("slack_webhook_host", "0.0.0.0")
         self.webhook_port = platform_config.get("slack_webhook_port", 3000)
         self.webhook_path = platform_config.get(
@@ -68,7 +67,7 @@ class SlackAdapter(Platform):
         self.metadata = PlatformMetadata(
             name="slack",
             description="适用于 Slack 的消息平台适配器，支持 Socket Mode 和 Webhook Mode。",
-            id=self.config.get("id"),
+            id=cast(str, self.config.get("id")),
             support_streaming_message=False,
         )
 
@@ -118,13 +117,13 @@ class SlackAdapter(Platform):
         logger.debug(f"[slack] RawMessage {event}")
 
         abm = AstrBotMessage()
-        abm.self_id = self.bot_self_id
+        abm.self_id = cast(str, self.bot_self_id)
 
         # 获取用户信息
         user_id = event.get("user", "")
         try:
             user_info = await self.web_client.users_info(user=user_id)
-            user_data = user_info["user"]
+            user_data = cast(dict, user_info["user"])
             user_name = user_data.get("real_name") or user_data.get("name", user_id)
         except Exception:
             user_name = user_id
@@ -135,7 +134,7 @@ class SlackAdapter(Platform):
         channel_id = event.get("channel", "")
         try:
             channel_info = await self.web_client.conversations_info(channel=channel_id)
-            is_im = channel_info["channel"]["is_im"]
+            is_im = cast(dict, channel_info["channel"])["is_im"]
 
             if is_im:
                 abm.type = MessageType.FRIEND_MESSAGE
@@ -178,7 +177,7 @@ class SlackAdapter(Platform):
                 for mention in mentions:
                     try:
                         mentioned_user = await self.web_client.users_info(user=mention)
-                        user_data = mentioned_user["user"]
+                        user_data = cast(dict, mentioned_user["user"])
                         user_name = user_data.get("real_name") or user_data.get(
                             "name",
                             mention,
@@ -329,7 +328,7 @@ class SlackAdapter(Platform):
                 )
                 raise Exception(f"下载文件失败: {resp.status}")
 
-    async def run(self) -> Awaitable[Any]:
+    async def run(self) -> None:
         self.bot_self_id = await self.get_bot_user_id()
         logger.info(f"Slack auth test OK. Bot ID: {self.bot_self_id}")
 
@@ -361,10 +360,17 @@ class SlackAdapter(Platform):
                 self._handle_webhook_event,
             )
 
-            logger.info(
-                f"Slack 适配器 (Webhook Mode) 启动中，监听 {self.webhook_host}:{self.webhook_port}{self.webhook_path}...",
-            )
-            await self.webhook_client.start()
+            # 如果启用统一 webhook 模式，则不启动独立服务器
+            webhook_uuid = self.config.get("webhook_uuid")
+            if self.unified_webhook_mode and webhook_uuid:
+                log_webhook_info(f"{self.meta().id}(Slack)", webhook_uuid)
+                # 保持运行状态，等待 shutdown
+                await self.webhook_client.shutdown_event.wait()
+            else:
+                logger.info(
+                    f"Slack 适配器 (Webhook Mode) 启动中，监听 {self.webhook_host}:{self.webhook_port}{self.webhook_path}...",
+                )
+                await self.webhook_client.start()
 
         else:
             raise ValueError(
@@ -391,12 +397,19 @@ class SlackAdapter(Platform):
             if abm:
                 await self.handle_msg(abm)
 
+    async def webhook_callback(self, request: Any) -> Any:
+        """统一 Webhook 回调入口"""
+        if self.connection_mode != "webhook" or not self.webhook_client:
+            return {"error": "Slack adapter is not in webhook mode"}, 400
+
+        return await self.webhook_client.handle_callback(request)
+
     async def terminate(self):
         if self.socket_client:
             await self.socket_client.stop()
         if self.webhook_client:
             await self.webhook_client.stop()
-        logger.info("Slack 适配器已被优雅地关闭")
+        logger.info("Slack 适配器已被关闭")
 
     def meta(self) -> PlatformMetadata:
         return self.metadata
@@ -414,3 +427,10 @@ class SlackAdapter(Platform):
 
     def get_client(self):
         return self.web_client
+
+    def unified_webhook(self) -> bool:
+        return bool(
+            self.config.get("unified_webhook_mode", False)
+            and self.config.get("slack_connection_mode", "") == "webhook"
+            and self.config.get("webhook_uuid")
+        )

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

@@ -1,6 +1,7 @@
 import asyncio
 import re
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Iterable
+from typing import cast
 
 from slack_sdk.web.async_client import AsyncWebClient
 
@@ -31,14 +32,14 @@ class SlackMessageEvent(AstrMessageEvent):
     async def _from_segment_to_slack_block(
         segment: BaseMessageComponent,
         web_client: AsyncWebClient,
-    ) -> dict:
+    ) -> dict | None:
         """将消息段转换为 Slack 块格式"""
         if isinstance(segment, Plain):
             return {"type": "section", "text": {"type": "mrkdwn", "text": segment.text}}
         if isinstance(segment, Image):
             # upload file
             url = segment.url or segment.file
-            if url.startswith("http"):
+            if url and url.startswith("http"):
                 return {
                     "type": "image",
                     "image_url": url,
@@ -55,7 +56,7 @@ class SlackMessageEvent(AstrMessageEvent):
                     "type": "section",
                     "text": {"type": "mrkdwn", "text": "图片上传失败"},
                 }
-            image_url = response["files"][0]["url_private"]
+            image_url = cast(list, response["files"])[0]["url_private"]
             logger.debug(f"Slack file upload response: {response}")
             return {
                 "type": "image",
@@ -77,7 +78,7 @@ class SlackMessageEvent(AstrMessageEvent):
                     "type": "section",
                     "text": {"type": "mrkdwn", "text": "文件上传失败"},
                 }
-            file_url = response["files"][0]["permalink"]
+            file_url = cast(list, response["files"])[0]["permalink"]
             return {
                 "type": "section",
                 "text": {
@@ -85,7 +86,6 @@ class SlackMessageEvent(AstrMessageEvent):
                     "text": f"文件: <{file_url}|{segment.name or '文件'}>",
                 },
             }
-        return {"type": "section", "text": {"type": "mrkdwn", "text": str(segment)}}
 
     @staticmethod
     async def _parse_slack_blocks(
@@ -115,7 +115,8 @@ class SlackMessageEvent(AstrMessageEvent):
                     segment,
                     web_client,
                 )
-                blocks.append(block)
+                if block:
+                    blocks.append(block)
 
         # 如果最后还有文本内容
         if text_content.strip():
@@ -225,10 +226,10 @@ class SlackMessageEvent(AstrMessageEvent):
             )
 
             members = []
-            for member_id in members_response["members"]:
+            for member_id in cast(Iterable, members_response["members"]):
                 try:
                     user_info = await self.web_client.users_info(user=member_id)
-                    user_data = user_info["user"]
+                    user_data = cast(dict, user_info["user"])
                     members.append(
                         MessageMember(
                             user_id=member_id,
@@ -240,7 +241,7 @@ class SlackMessageEvent(AstrMessageEvent):
                     # 如果获取用户信息失败，使用默认信息
                     members.append(MessageMember(user_id=member_id, nickname=member_id))
 
-            channel_data = channel_info["channel"]
+            channel_data = cast(dict, channel_info["channel"])
             return Group(
                 group_id=channel_id,
                 group_name=channel_data.get("name", ""),

astrbot/core/platform/sources/telegram/tg_adapter.py

@@ -42,8 +42,7 @@ class TelegramPlatformAdapter(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 = uuid.uuid4().hex[:8]
 
@@ -425,6 +424,6 @@ class TelegramPlatformAdapter(Platform):
             if self.application.updater is not None:
                 await self.application.updater.stop()
 
-            logger.info("Telegram 适配器已被优雅地关闭")
+            logger.info("Telegram 适配器已被关闭")
         except Exception as e:
             logger.error(f"Telegram 适配器关闭时出错: {e}")

astrbot/core/platform/sources/telegram/tg_event.py

@@ -1,6 +1,7 @@
 import asyncio
 import os
 import re
+from typing import Any, cast
 
 import telegramify_markdown
 from telegram import ReactionTypeCustomEmoji, ReactionTypeEmoji
@@ -17,8 +18,6 @@ from astrbot.api.message_components import (
     Reply,
 )
 from astrbot.api.platform import AstrBotMessage, MessageType, PlatformMetadata
-from astrbot.core.utils.astrbot_path import get_astrbot_data_path
-from astrbot.core.utils.io import download_file
 
 
 class TelegramPlatformEvent(AstrMessageEvent):
@@ -97,7 +96,7 @@ class TelegramPlatformEvent(AstrMessageEvent):
                 "chat_id": user_name,
             }
             if has_reply:
-                payload["reply_to_message_id"] = reply_message_id
+                payload["reply_to_message_id"] = str(reply_message_id)
             if message_thread_id:
                 payload["message_thread_id"] = message_thread_id
 
@@ -110,33 +109,30 @@ class TelegramPlatformEvent(AstrMessageEvent):
                     try:
                         md_text = telegramify_markdown.markdownify(
                             chunk,
-                            max_line_length=None,
                             normalize_whitespace=False,
                         )
                         await client.send_message(
                             text=md_text,
                             parse_mode="MarkdownV2",
-                            **payload,
+                            **cast(Any, payload),
                         )
                     except Exception as e:
                         logger.warning(
                             f"MarkdownV2 send failed: {e}. Using plain text instead.",
                         )
-                        await client.send_message(text=chunk, **payload)
+                        await client.send_message(text=chunk, **cast(Any, payload))
             elif isinstance(i, Image):
                 image_path = await i.convert_to_file_path()
-                await client.send_photo(photo=image_path, **payload)
+                await client.send_photo(photo=image_path, **cast(Any, payload))
             elif isinstance(i, File):
-                if i.file.startswith("https://"):
-                    temp_dir = os.path.join(get_astrbot_data_path(), "temp")
-                    path = os.path.join(temp_dir, i.name)
-                    await download_file(i.file, path)
-                    i.file = path
-
-                await client.send_document(document=i.file, filename=i.name, **payload)
+                path = await i.get_file()
+                name = i.name or os.path.basename(path)
+                await client.send_document(
+                    document=path, filename=name, **cast(Any, payload)
+                )
             elif isinstance(i, Record):
                 path = await i.convert_to_file_path()
-                await client.send_voice(voice=path, **payload)
+                await client.send_voice(voice=path, **cast(Any, payload))
 
     async def send(self, message: MessageChain):
         if self.get_message_type() == MessageType.GROUP_MESSAGE:
@@ -214,24 +210,23 @@ class TelegramPlatformEvent(AstrMessageEvent):
                         delta += i.text
                     elif isinstance(i, Image):
                         image_path = await i.convert_to_file_path()
-                        await self.client.send_photo(photo=image_path, **payload)
+                        await self.client.send_photo(
+                            photo=image_path, **cast(Any, payload)
+                        )
                         continue
                     elif isinstance(i, File):
-                        if i.file.startswith("https://"):
-                            temp_dir = os.path.join(get_astrbot_data_path(), "temp")
-                            path = os.path.join(temp_dir, i.name)
-                            await download_file(i.file, path)
-                            i.file = path
+                        path = await i.get_file()
+                        name = i.name or os.path.basename(path)
 
                         await self.client.send_document(
-                            document=i.file,
-                            filename=i.name,
-                            **payload,
+                            document=path,
+                            filename=name,
+                            **cast(Any, payload),
                         )
                         continue
                     elif isinstance(i, Record):
                         path = await i.convert_to_file_path()
-                        await self.client.send_voice(voice=path, **payload)
+                        await self.client.send_voice(voice=path, **cast(Any, payload))
                         continue
                     else:
                         logger.warning(f"不支持的消息类型: {type(i)}")
@@ -260,7 +255,9 @@ class TelegramPlatformEvent(AstrMessageEvent):
                 else:
                     # delta 长度一般不会大于 4096，因此这里直接发送
                     try:
-                        msg = await self.client.send_message(text=delta, **payload)
+                        msg = await self.client.send_message(
+                            text=delta, **cast(Any, payload)
+                        )
                         current_content = delta
                     except Exception as e:
                         logger.warning(f"发送消息失败(streaming): {e!s}")
@@ -274,7 +271,6 @@ class TelegramPlatformEvent(AstrMessageEvent):
                 try:
                     markdown_text = telegramify_markdown.markdownify(
                         delta,
-                        max_line_length=None,
                         normalize_whitespace=False,
                     )
                     await self.client.edit_message_text(