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

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

@@ -1,10 +1,10 @@
 import asyncio
 import re
 import sys
-from typing import Any
+from typing import Any, cast
 
 import discord
-from discord.abc import Messageable
+from discord.abc import GuildChannel, Messageable, PrivateChannel
 from discord.channel import DMChannel
 
 from astrbot import logger
@@ -46,7 +46,7 @@ class DiscordPlatformAdapter(Platform):
     ) -> None:
         super().__init__(platform_config, event_queue)
         self.settings = platform_settings
-        self.client_self_id = None
+        self.client_self_id: str | None = None
         self.registered_handlers = []
         # 指令注册相关
         self.enable_command_register = self.config.get("discord_command_register", True)
@@ -62,6 +62,12 @@ class DiscordPlatformAdapter(Platform):
         message_chain: MessageChain,
     ):
         """通过会话发送消息"""
+        if self.client.user is None:
+            logger.error(
+                "[Discord] 客户端未就绪 (self.client.user is None)，无法发送消息"
+            )
+            return
+
         # 创建一个 message_obj 以便在 event 中使用
         message_obj = AstrBotMessage()
         if "_" in session.session_id:
@@ -89,7 +95,7 @@ class DiscordPlatformAdapter(Platform):
             user_id=str(self.client_self_id),
             nickname=self.client.user.display_name,
         )
-        message_obj.self_id = self.client_self_id
+        message_obj.self_id = cast(str, self.client_self_id)
         message_obj.session_id = session.session_id
         message_obj.message = message_chain.chain
 
@@ -110,7 +116,7 @@ class DiscordPlatformAdapter(Platform):
         return PlatformMetadata(
             "discord",
             "Discord 适配器",
-            id=self.config.get("id"),
+            id=cast(str, self.config.get("id")),
             default_config_tmpl=self.config,
             support_streaming_message=False,
         )
@@ -160,7 +166,7 @@ class DiscordPlatformAdapter(Platform):
 
     def _get_message_type(
         self,
-        channel: Messageable,
+        channel: Messageable | GuildChannel | PrivateChannel,
         guild_id: int | None = None,
     ) -> MessageType:
         """根据 channel 对象和 guild_id 判断消息类型"""
@@ -170,13 +176,15 @@ class DiscordPlatformAdapter(Platform):
             return MessageType.FRIEND_MESSAGE
         return MessageType.GROUP_MESSAGE
 
-    def _get_channel_id(self, channel: Messageable) -> str:
+    def _get_channel_id(
+        self, channel: Messageable | GuildChannel | PrivateChannel
+    ) -> str:
         """根据 channel 对象获取ID"""
         return str(getattr(channel, "id", None))
 
     def _convert_message_to_abm(self, data: dict) -> AstrBotMessage:
         """将普通消息转换为 AstrBotMessage"""
-        message: discord.Message = data["message"]
+        message = data["message"]
 
         content = message.content
 
@@ -233,7 +241,7 @@ class DiscordPlatformAdapter(Platform):
                     )
         abm.message = message_chain
         abm.raw_message = message
-        abm.self_id = self.client_self_id
+        abm.self_id = cast(str, self.client_self_id)
         abm.session_id = str(message.channel.id)
         abm.message_id = str(message.id)
         return abm
@@ -254,32 +262,52 @@ class DiscordPlatformAdapter(Platform):
             interaction_followup_webhook=followup_webhook,
         )
 
+        if self.client.user is None:
+            logger.error(
+                "[Discord] 客户端未就绪 (self.client.user is None)，无法处理消息"
+            )
+            return
+
         # 检查是否为斜杠指令
         is_slash_command = message_event.interaction_followup_webhook is not None
 
+        # 1. 优先处理斜杠指令
+        if is_slash_command:
+            message_event.is_wake = True
+            message_event.is_at_or_wake_command = True
+            self.commit_event(message_event)
+            return
+
+        # 2. 处理普通消息（提及检测）
+        # 确保 raw_message 是 discord.Message 类型，以便静态检查通过
+        raw_message = message.raw_message
+        if not isinstance(raw_message, discord.Message):
+            logger.warning(
+                f"[Discord] 收到非 Message 类型的消息: {type(raw_message)}，已忽略。"
+            )
+            return
+
         # 检查是否被@（User Mention 或 Bot 拥有的 Role Mention）
         is_mention = False
+
         # User Mention
-        if (
-            self.client
-            and self.client.user
-            and hasattr(message.raw_message, "mentions")
-        ):
-            if self.client.user in message.raw_message.mentions:
-                is_mention = True
+        # 此时 Pylance 知道 raw_message 是 discord.Message，具有 mentions 属性
+        if self.client.user in raw_message.mentions:
+            is_mention = True
+
         # Role Mention（Bot 拥有的角色被提及）
-        if not is_mention and hasattr(message.raw_message, "role_mentions"):
+        if not is_mention and raw_message.role_mentions:
             bot_member = None
-            if hasattr(message.raw_message, "guild") and message.raw_message.guild:
+            if raw_message.guild:
                 try:
-                    bot_member = message.raw_message.guild.get_member(
+                    bot_member = raw_message.guild.get_member(
                         self.client.user.id,
                     )
                 except Exception:
                     bot_member = None
             if bot_member and hasattr(bot_member, "roles"):
                 bot_roles = set(bot_member.roles)
-                mentioned_roles = set(message.raw_message.role_mentions)
+                mentioned_roles = set(raw_message.role_mentions)
                 if (
                     bot_roles
                     and mentioned_roles
@@ -287,8 +315,8 @@ class DiscordPlatformAdapter(Platform):
                 ):
                     is_mention = True
 
-        # 如果是斜杠指令或被@的消息，设置为唤醒状态
-        if is_slash_command or is_mention:
+        # 如果是被@的消息，设置为唤醒状态
+        if is_mention:
             message_event.is_wake = True
             message_event.is_at_or_wake_command = True
 
@@ -424,7 +452,7 @@ class DiscordPlatformAdapter(Platform):
             )
             abm.message = [Plain(text=message_str_for_filter)]
             abm.raw_message = ctx.interaction
-            abm.self_id = self.client_self_id
+            abm.self_id = cast(str, self.client_self_id)
             abm.session_id = str(ctx.channel_id)
             abm.message_id = str(ctx.interaction.id)
 
@@ -437,7 +465,7 @@ class DiscordPlatformAdapter(Platform):
     def _extract_command_info(
         event_filter: Any,
         handler_metadata: StarHandlerMetadata,
-    ) -> tuple[str, str, CommandFilter] | None:
+    ) -> tuple[str, str, CommandFilter | None] | None:
         """从事件过滤器中提取指令信息"""
         cmd_name = None
         # is_group = False

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

@@ -4,8 +4,10 @@ import binascii
 from collections.abc import AsyncGenerator
 from io import BytesIO
 from pathlib import Path
+from typing import cast
 
 import discord
+from discord.types.interactions import ComponentInteractionData
 
 from astrbot import logger
 from astrbot.api.event import AstrMessageEvent, MessageChain
@@ -85,6 +87,9 @@ class DiscordPlatformEvent(AstrMessageEvent):
                 channel = await self._get_channel()
                 if not channel:
                     return
+                if not isinstance(channel, discord.abc.Messageable):
+                    logger.error(f"[Discord] 频道 {channel.id} 不是可发送消息的类型")
+                    return
                 await channel.send(**kwargs)
 
         except Exception as e:
@@ -107,7 +112,9 @@ class DiscordPlatformEvent(AstrMessageEvent):
         await self.send(buffer)
         return await super().send_streaming(generator, use_fallback)
 
-    async def _get_channel(self) -> discord.abc.Messageable | None:
+    async def _get_channel(
+        self,
+    ) -> discord.Thread | discord.abc.GuildChannel | discord.abc.PrivateChannel | None:
         """获取当前事件对应的频道对象"""
         try:
             channel_id = int(self.session_id)
@@ -121,7 +128,13 @@ class DiscordPlatformEvent(AstrMessageEvent):
     async def _parse_to_discord(
         self,
         message: MessageChain,
-    ) -> tuple[str, list[discord.File], discord.ui.View | None, list[discord.Embed]]:
+    ) -> tuple[
+        str,
+        list[discord.File],
+        discord.ui.View | None,
+        list[discord.Embed],
+        str | int | None,
+    ]:
         """将 MessageChain 解析为 Discord 发送所需的内容"""
         content_parts = []
         files = []
@@ -261,7 +274,9 @@ class DiscordPlatformEvent(AstrMessageEvent):
                 self.message_obj.raw_message,
                 "add_reaction",
             ):
-                await self.message_obj.raw_message.add_reaction(emoji)
+                await cast(discord.Message, self.message_obj.raw_message).add_reaction(
+                    emoji
+                )
         except Exception as e:
             logger.error(f"[Discord] 添加反应失败: {e}")
 
@@ -270,7 +285,7 @@ class DiscordPlatformEvent(AstrMessageEvent):
         return (
             hasattr(self.message_obj, "raw_message")
             and hasattr(self.message_obj.raw_message, "type")
-            and self.message_obj.raw_message.type
+            and cast(discord.Interaction, self.message_obj.raw_message).type
             == discord.InteractionType.application_command
         )
 
@@ -279,14 +294,18 @@ class DiscordPlatformEvent(AstrMessageEvent):
         return (
             hasattr(self.message_obj, "raw_message")
             and hasattr(self.message_obj.raw_message, "type")
-            and self.message_obj.raw_message.type == discord.InteractionType.component
+            and cast(discord.Interaction, self.message_obj.raw_message).type
+            == discord.InteractionType.component
         )
 
     def get_interaction_custom_id(self) -> str:
         """获取交互组件的custom_id"""
         if self.is_button_interaction():
             try:
-                return self.message_obj.raw_message.data.get("custom_id", "")
+                return cast(
+                    ComponentInteractionData,
+                    cast(discord.Interaction, self.message_obj.raw_message).data,
+                ).get("custom_id", "")
             except Exception:
                 pass
         return ""
@@ -299,7 +318,9 @@ class DiscordPlatformEvent(AstrMessageEvent):
         ):
             return any(
                 mention.id == int(self.message_obj.self_id)
-                for mention in self.message_obj.raw_message.mentions
+                for mention in cast(
+                    discord.Message, self.message_obj.raw_message
+                ).mentions
             )
         return False
 
@@ -309,5 +330,5 @@ class DiscordPlatformEvent(AstrMessageEvent):
             self.message_obj.raw_message,
             "clean_content",
         ):
-            return self.message_obj.raw_message.clean_content
+            return cast(discord.Message, self.message_obj.raw_message).clean_content
         return self.message_str

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

@@ -2,10 +2,17 @@ import asyncio
 import base64
 import json
 import re
+import time
 import uuid
+from typing import Any, cast
 
 import lark_oapi as lark
-from lark_oapi.api.im.v1 import *
+from lark_oapi.api.im.v1 import (
+    CreateMessageRequest,
+    CreateMessageRequestBody,
+    GetMessageResourceRequest,
+)
+from lark_oapi.api.im.v1.processor import P2ImMessageReceiveV1Processor
 
 import astrbot.api.message_components as Comp
 from astrbot import logger
@@ -18,9 +25,11 @@ 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 .lark_event import LarkMessageEvent
+from .server import LarkWebhookServer
 
 
 @register_platform_adapter(
@@ -42,9 +51,13 @@ class LarkPlatformAdapter(Platform):
         self.domain = platform_config.get("domain", lark.FEISHU_DOMAIN)
         self.bot_name = platform_config.get("lark_bot_name", "astrbot")
 
+        # socket or webhook
+        self.connection_mode = platform_config.get("lark_connection_mode", "socket")
+
         if not self.bot_name:
             logger.warning("未设置飞书机器人名称，@ 机器人可能得不到回复。")
 
+        # 初始化 WebSocket 长连接相关配置
         async def on_msg_event_recv(event: lark.im.v1.P2ImMessageReceiveV1):
             await self.convert_msg(event)
 
@@ -57,6 +70,8 @@ class LarkPlatformAdapter(Platform):
             .build()
         )
 
+        self.do_v2_msg_event = do_v2_msg_event
+
         self.client = lark.ws.Client(
             app_id=self.appid,
             app_secret=self.appsecret,
@@ -69,11 +84,48 @@ class LarkPlatformAdapter(Platform):
             lark.Client.builder().app_id(self.appid).app_secret(self.appsecret).build()
         )
 
+        self.webhook_server = None
+        if self.connection_mode == "webhook":
+            self.webhook_server = LarkWebhookServer(platform_config, event_queue)
+            self.webhook_server.set_callback(self.handle_webhook_event)
+
+        self.event_id_timestamps: dict[str, float] = {}
+
+    def _clean_expired_events(self):
+        """清理超过 30 分钟的事件记录"""
+        current_time = time.time()
+        expired_keys = [
+            event_id
+            for event_id, timestamp in self.event_id_timestamps.items()
+            if current_time - timestamp > 1800
+        ]
+        for event_id in expired_keys:
+            del self.event_id_timestamps[event_id]
+
+    def _is_duplicate_event(self, event_id: str) -> bool:
+        """检查事件是否重复
+
+        Args:
+            event_id: 事件ID
+
+        Returns:
+            True 表示重复事件，False 表示新事件
+        """
+        self._clean_expired_events()
+        if event_id in self.event_id_timestamps:
+            return True
+        self.event_id_timestamps[event_id] = time.time()
+        return False
+
     async def send_by_session(
         self,
         session: MessageSesion,
         message_chain: MessageChain,
     ):
+        if self.lark_api.im is None:
+            logger.error("[Lark] API Client im 模块未初始化，无法发送消息")
+            return
+
         res = await LarkMessageEvent._convert_to_lark(message_chain, self.lark_api)
         wrapped = {
             "zh_cn": {
@@ -114,14 +166,25 @@ class LarkPlatformAdapter(Platform):
         return PlatformMetadata(
             name="lark",
             description="飞书机器人官方 API 适配器",
-            id=self.config.get("id"),
+            id=cast(str, self.config.get("id")),
             support_streaming_message=False,
         )
 
     async def convert_msg(self, event: lark.im.v1.P2ImMessageReceiveV1):
+        if event.event is None:
+            logger.debug("[Lark] 收到空事件(event.event is None)")
+            return
         message = event.event.message
+        if message is None:
+            logger.debug("[Lark] 事件中没有消息体(message is None)")
+            return
+
         abm = AstrBotMessage()
-        abm.timestamp = int(message.create_time) / 1000
+
+        if message.create_time:
+            abm.timestamp = int(message.create_time) // 1000
+        else:
+            abm.timestamp = int(time.time())
         abm.message = []
         abm.type = (
             MessageType.GROUP_MESSAGE
@@ -136,14 +199,28 @@ class LarkPlatformAdapter(Platform):
         at_list = {}
         if message.mentions:
             for m in message.mentions:
-                at_list[m.key] = Comp.At(qq=m.id.open_id, name=m.name)
+                if m.id is None:
+                    continue
+                # 飞书 open_id 可能是 None，这里做个防护
+                open_id = m.id.open_id if m.id.open_id else ""
+                at_list[m.key] = Comp.At(qq=open_id, name=m.name)
+
                 if m.name == self.bot_name:
-                    abm.self_id = m.id.open_id
+                    if m.id.open_id is not None:
+                        abm.self_id = m.id.open_id
+
+        if message.content is None:
+            logger.warning("[Lark] 消息内容为空")
+            return
 
-        content_json_b = json.loads(message.content)
+        try:
+            content_json_b = json.loads(message.content)
+        except json.JSONDecodeError:
+            logger.error(f"[Lark] 解析消息内容失败: {message.content}")
+            return
 
         if message.message_type == "text":
-            message_str_raw = content_json_b["text"]  # 带有 @ 的消息
+            message_str_raw = content_json_b.get("text", "")  # 带有 @ 的消息
             at_pattern = r"(@_user_\d+)"  # 可以根据需求修改正则
             # at_users = re.findall(at_pattern, message_str_raw)
             # 拆分文本，去掉AT符号部分
@@ -168,27 +245,47 @@ class LarkPlatformAdapter(Platform):
             content_json_b = _ls
         elif message.message_type == "image":
             content_json_b = [
-                {"tag": "img", "image_key": content_json_b["image_key"], "style": []},
+                {
+                    "tag": "img",
+                    "image_key": content_json_b.get("image_key"),
+                    "style": [],
+                },
             ]
 
         if message.message_type in ("post", "image"):
             for comp in content_json_b:
-                if comp["tag"] == "at":
-                    abm.message.append(at_list[comp["user_id"]])
-                elif comp["tag"] == "text" and comp["text"].strip():
+                if comp.get("tag") == "at":
+                    user_id = comp.get("user_id")
+                    if user_id in at_list:
+                        abm.message.append(at_list[user_id])
+                elif comp.get("tag") == "text" and comp.get("text", "").strip():
                     abm.message.append(Comp.Plain(comp["text"].strip()))
-                elif comp["tag"] == "img":
-                    image_key = comp["image_key"]
+                elif comp.get("tag") == "img":
+                    image_key = comp.get("image_key")
+                    if not image_key:
+                        continue
+
                     request = (
                         GetMessageResourceRequest.builder()
-                        .message_id(message.message_id)
+                        .message_id(cast(str, message.message_id))
                         .file_key(image_key)
                         .type("image")
                         .build()
                     )
+
+                    if self.lark_api.im is None:
+                        logger.error("[Lark] API Client im 模块未初始化")
+                        continue
+
                     response = await self.lark_api.im.v1.message_resource.aget(request)
                     if not response.success():
                         logger.error(f"无法下载飞书图片: {image_key}")
+                        continue
+
+                    if response.file is None:
+                        logger.error(f"飞书图片响应中不包含文件流: {image_key}")
+                        continue
+
                     image_bytes = response.file.read()
                     image_base64 = base64.b64encode(image_bytes).decode()
                     abm.message.append(Comp.Image.fromBase64(image_base64))
@@ -196,6 +293,19 @@ class LarkPlatformAdapter(Platform):
         for comp in abm.message:
             if isinstance(comp, Comp.Plain):
                 abm.message_str += comp.text
+
+        if message.message_id is None:
+            logger.error("[Lark] 消息缺少 message_id")
+            return
+
+        if (
+            event.event.sender is None
+            or event.event.sender.sender_id is None
+            or event.event.sender.sender_id.open_id is None
+        ):
+            logger.error("[Lark] 消息发送者信息不完整")
+            return
+
         abm.message_id = message.message_id
         abm.raw_message = message
         abm.sender = MessageMember(
@@ -227,13 +337,61 @@ class LarkPlatformAdapter(Platform):
 
         self._event_queue.put_nowait(event)
 
+    async def handle_webhook_event(self, event_data: dict):
+        """处理 Webhook 事件
+
+        Args:
+            event_data: Webhook 事件数据
+        """
+        try:
+            header = event_data.get("header", {})
+            event_id = header.get("event_id", "")
+            if event_id and self._is_duplicate_event(event_id):
+                logger.debug(f"[Lark Webhook] 跳过重复事件: {event_id}")
+                return
+            event_type = header.get("event_type", "")
+            if event_type == "im.message.receive_v1":
+                processor = P2ImMessageReceiveV1Processor(self.do_v2_msg_event)
+                data = (processor.type())(event_data)
+                processor.do(data)
+            else:
+                logger.debug(f"[Lark Webhook] 未处理的事件类型: {event_type}")
+        except Exception as e:
+            logger.error(f"[Lark Webhook] 处理事件失败: {e}", exc_info=True)
+
     async def run(self):
-        # self.client.start()
-        await self.client._connect()
+        if self.connection_mode == "webhook":
+            # Webhook 模式
+            if self.webhook_server is None:
+                logger.error("[Lark] Webhook 模式已启用，但 webhook_server 未初始化")
+                return
+
+            webhook_uuid = self.config.get("webhook_uuid")
+            if webhook_uuid:
+                log_webhook_info(f"{self.meta().id}(飞书 Webhook)", webhook_uuid)
+            else:
+                logger.warning("[Lark] Webhook 模式已启用，但未配置 webhook_uuid")
+        else:
+            # 长连接模式
+            await self.client._connect()
+
+    async def webhook_callback(self, request: Any) -> Any:
+        """统一 Webhook 回调入口"""
+        if not self.webhook_server:
+            return {"error": "Webhook server not initialized"}, 500
+
+        return await self.webhook_server.handle_callback(request)
 
     async def terminate(self):
-        await self.client._disconnect()
-        logger.info("飞书(Lark) 适配器已被优雅地关闭")
+        if self.connection_mode == "socket":
+            await self.client._disconnect()
+        logger.info("飞书(Lark) 适配器已关闭")
 
-    def get_client(self) -> lark.Client:
+    def get_client(self) -> lark.ws.Client:
         return self.client
+
+    def unified_webhook(self) -> bool:
+        return bool(
+            self.config.get("lark_connection_mode", "") == "webhook"
+            and self.config.get("webhook_uuid")
+        )

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

@@ -5,7 +5,15 @@ import uuid
 from io import BytesIO
 
 import lark_oapi as lark
-from lark_oapi.api.im.v1 import *
+from lark_oapi.api.im.v1 import (
+    CreateImageRequest,
+    CreateImageRequestBody,
+    CreateMessageReactionRequest,
+    CreateMessageReactionRequestBody,
+    Emoji,
+    ReplyMessageRequest,
+    ReplyMessageRequestBody,
+)
 
 from astrbot import logger
 from astrbot.api.event import AstrMessageEvent, MessageChain
@@ -44,7 +52,7 @@ class LarkMessageEvent(AstrMessageEvent):
                     file_path = comp.file.replace("file:///", "")
                 elif comp.file and comp.file.startswith("http"):
                     image_file_path = await download_image_by_url(comp.file)
-                    file_path = image_file_path
+                    file_path = image_file_path if image_file_path else ""
                 elif comp.file and comp.file.startswith("base64://"):
                     base64_str = comp.file.removeprefix("base64://")
                     image_data = base64.b64decode(base64_str)
@@ -54,10 +62,17 @@ class LarkMessageEvent(AstrMessageEvent):
                     with open(file_path, "wb") as f:
                         f.write(BytesIO(image_data).getvalue())
                 else:
-                    file_path = comp.file
+                    file_path = comp.file if comp.file else ""
 
                 if image_file is None:
-                    image_file = open(file_path, "rb")
+                    if not file_path:
+                        logger.error("[Lark] 图片路径为空，无法上传")
+                        continue
+                    try:
+                        image_file = open(file_path, "rb")
+                    except Exception as e:
+                        logger.error(f"[Lark] 无法打开图片文件: {e}")
+                        continue
 
                 request = (
                     CreateImageRequest.builder()
@@ -69,9 +84,20 @@ class LarkMessageEvent(AstrMessageEvent):
                     )
                     .build()
                 )
+
+                if lark_client.im is None:
+                    logger.error("[Lark] API Client im 模块未初始化，无法上传图片")
+                    continue
+
                 response = await lark_client.im.v1.image.acreate(request)
                 if not response.success():
                     logger.error(f"无法上传飞书图片({response.code}): {response.msg}")
+                    continue
+
+                if response.data is None:
+                    logger.error("[Lark] 上传图片成功但未返回数据(data is None)")
+                    continue
+
                 image_key = response.data.image_key
                 logger.debug(image_key)
                 ret.append(_stage)
@@ -107,6 +133,10 @@ class LarkMessageEvent(AstrMessageEvent):
             .build()
         )
 
+        if self.bot.im is None:
+            logger.error("[Lark] API Client im 模块未初始化，无法回复消息")
+            return
+
         response = await self.bot.im.v1.message.areply(request)
 
         if not response.success():
@@ -115,6 +145,10 @@ class LarkMessageEvent(AstrMessageEvent):
         await super().send(message)
 
     async def react(self, emoji: str):
+        if self.bot.im is None:
+            logger.error("[Lark] API Client im 模块未初始化，无法发送表情")
+            return
+
         request = (
             CreateMessageReactionRequest.builder()
             .message_id(self.message_obj.message_id)
@@ -125,6 +159,7 @@ class LarkMessageEvent(AstrMessageEvent):
             )
             .build()
         )
+
         response = await self.bot.im.v1.message_reaction.acreate(request)
         if not response.success():
             logger.error(f"发送飞书表情回应失败({response.code}): {response.msg}")