AstrBot 3.5.6__py3-none-any.whl → 4.7.0__py3-none-any.whl

astrbot/core/star/star_tools.py

@@ -1,38 +1,68 @@
+"""插件开发工具集
+封装了许多常用的操作，方便插件开发者使用
+
+说明:
+
+主动发送消息: send_message(session, message_chain)
+    根据 session (unified_msg_origin) 主动发送消息, 前提是需要提前获得或构造 session
+
+根据id直接主动发送消息: send_message_by_id(type, id, message_chain, platform="aiocqhttp")
+    根据 id (例如 qq 号, 群号等) 直接, 主动地发送消息
+
+以上两种方式需要构造消息链, 也就是消息组件的列表
+
+构造事件:
+
+首先需要构造一个 AstrBotMessage 对象, 使用 create_message 方法
+然后使用 create_event 方法提交事件到指定平台
+"""
+
 import inspect
-from typing import Union, Awaitable, List, Optional, ClassVar
+import os
+import uuid
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+from typing import Any, ClassVar
+
+from astrbot.api.platform import AstrBotMessage, MessageMember, MessageType
 from astrbot.core.message.components import BaseMessageComponent
 from astrbot.core.message.message_event_result import MessageChain
-from astrbot.api.platform import MessageMember, AstrBotMessage
 from astrbot.core.platform.astr_message_event import MessageSesion
+from astrbot.core.platform.sources.aiocqhttp.aiocqhttp_message_event import (
+    AiocqhttpMessageEvent,
+)
+from astrbot.core.platform.sources.aiocqhttp.aiocqhttp_platform_adapter import (
+    AiocqhttpAdapter,
+)
 from astrbot.core.star.context import Context
 from astrbot.core.star.star import star_map
-from pathlib import Path
+from astrbot.core.utils.astrbot_path import get_astrbot_data_path
 
 
 class StarTools:
-    """
-    提供给插件使用的便捷工具函数集合
+    """提供给插件使用的便捷工具函数集合
     这些方法封装了一些常用操作，使插件开发更加简单便捷!
     """
 
-    _context: ClassVar[Optional[Context]] = None
+    _context: ClassVar[Context | None] = None
 
     @classmethod
     def initialize(cls, context: Context) -> None:
-        """
-        初始化StarTools，设置context引用
+        """初始化StarTools，设置context引用
 
         Args:
             context: 暴露给插件的上下文
+
         """
         cls._context = context
 
     @classmethod
     async def send_message(
-        cls, session: Union[str, MessageSesion], message_chain: MessageChain
+        cls,
+        session: str | MessageSesion,
+        message_chain: MessageChain,
     ) -> bool:
-        """
-        根据session(unified_msg_origin)主动发送消息
+        """根据session(unified_msg_origin)主动发送消息
 
         Args:
             session: 消息会话。通过event.session或者event.unified_msg_origin获取
@@ -46,43 +76,85 @@ class StarTools:
 
         Note:
             qq_official(QQ官方API平台)不支持此方法
+
         """
+        if cls._context is None:
+            raise ValueError("StarTools not initialized")
         return await cls._context.send_message(session, message_chain)
 
+    @classmethod
+    async def send_message_by_id(
+        cls,
+        type: str,
+        id: str,
+        message_chain: MessageChain,
+        platform: str = "aiocqhttp",
+    ):
+        """根据 id(例如qq号, 群号等) 直接, 主动地发送消息
+
+        Args:
+            type (str): 消息类型, 可选: PrivateMessage, GroupMessage
+            id (str): 目标ID, 例如QQ号, 群号等
+            message_chain (MessageChain): 消息链
+            platform (str): 可选的平台名称，默认平台(aiocqhttp), 目前只支持 aiocqhttp
+
+        """
+        if cls._context is None:
+            raise ValueError("StarTools not initialized")
+        platforms = cls._context.platform_manager.get_insts()
+        if platform == "aiocqhttp":
+            adapter = next(
+                (p for p in platforms if isinstance(p, AiocqhttpAdapter)),
+                None,
+            )
+            if adapter is None:
+                raise ValueError("未找到适配器: AiocqhttpAdapter")
+            await AiocqhttpMessageEvent.send_message(
+                bot=adapter.bot,
+                message_chain=message_chain,
+                is_group=(type == "GroupMessage"),
+                session_id=id,
+            )
+        else:
+            raise ValueError(f"不支持的平台: {platform}")
+
     @classmethod
     async def create_message(
         cls,
         type: str,
         self_id: str,
         session_id: str,
-        message_id: str,
         sender: MessageMember,
-        message: List[BaseMessageComponent],
+        message: list[BaseMessageComponent],
         message_str: str,
-        raw_message: object,
+        message_id: str = "",
+        raw_message: object = None,
         group_id: str = "",
-    ):
-        """
-        创建一个AstrBot消息对象
+    ) -> AstrBotMessage:
+        """创建一个AstrBot消息对象
 
         Args:
-            type (str): 消息类型
+            type (str): 消息类型, 例如 "GroupMessage" "FriendMessage" "OtherMessage"
             self_id (str): 机器人自身ID
             session_id (str): 会话ID(通常为用户ID)(QQ号, 群号等)
-            message_id (str): 消息ID
-            sender (MessageMember): 发送者信息
-            message (List[BaseMessageComponent]): 消息组件列表
-            message_str (str): 消息字符串
-            raw_message (object): 原始消息对象
+            sender (MessageMember): 发送者信息, 例如 MessageMember(user_id="123456", nickname="昵称")
+            message (List[BaseMessageComponent]): 消息组件列表, 也就是消息链, 这个不会发给 llm, 但是会经过其他处理
+            message_str (str): 消息字符串, 也就是纯文本消息, 也就是发送给 llm 的消息, 与消息链一致
+
+            message_id (str): 消息ID, 构造消息时可以随意填写也可不填
+            raw_message (object): 原始消息对象, 可以随意填写也可不填
             group_id (str, optional): 群组ID, 如果为私聊则为空. Defaults to "".
 
         Returns:
             AstrBotMessage: 创建的消息对象
+
         """
         abm = AstrBotMessage()
-        abm.type = type
+        abm.type = MessageType(type)
         abm.self_id = self_id
         abm.session_id = session_id
+        if message_id == "":
+            message_id = uuid.uuid4().hex
         abm.message_id = message_id
         abm.sender = sender
         abm.message = message
@@ -91,65 +163,106 @@ class StarTools:
         abm.group_id = group_id
         return abm
 
-    # todo: 添加构造事件的方法
-    # async def create_event(
-    #     self, platform: str, umo: str, sender_id: str, session_id: str
-    # ):
-    #     platform = self._context.get_platform(platform)
+    @classmethod
+    async def create_event(
+        cls,
+        abm: AstrBotMessage,
+        platform: str = "aiocqhttp",
+        is_wake: bool = True,
+    ) -> None:
+        """创建并提交事件到指定平台
+        当有需要创建一个事件, 触发某些处理流程时, 使用该方法
+
+        Args:
+            abm (AstrBotMessage): 要提交的消息对象, 请先使用 create_message 创建
+            platform (str): 可选的平台名称，默认平台(aiocqhttp), 目前只支持 aiocqhttp
+            is_wake (bool): 是否标记为唤醒事件, 默认为 True, 只有唤醒事件才会被 llm 响应
 
-    # todo: 添加找到对应平台并提交对应事件的方法
+        """
+        if cls._context is None:
+            raise ValueError("StarTools not initialized")
+        platforms = cls._context.platform_manager.get_insts()
+        if platform == "aiocqhttp":
+            adapter = next(
+                (p for p in platforms if isinstance(p, AiocqhttpAdapter)),
+                None,
+            )
+            if adapter is None:
+                raise ValueError("未找到适配器: AiocqhttpAdapter")
+            event = AiocqhttpMessageEvent(
+                message_str=abm.message_str,
+                message_obj=abm,
+                platform_meta=adapter.metadata,
+                session_id=abm.session_id,
+                bot=adapter.bot,
+            )
+            event.is_wake = is_wake
+            adapter.commit_event(event)
+        else:
+            raise ValueError(f"不支持的平台: {platform}")
 
     @classmethod
     def activate_llm_tool(cls, name: str) -> bool:
-        """
-        激活一个已经注册的函数调用工具
+        """激活一个已经注册的函数调用工具
         注册的工具默认是激活状态
 
         Args:
             name (str): 工具名称
+
         """
+        if cls._context is None:
+            raise ValueError("StarTools not initialized")
         return cls._context.activate_llm_tool(name)
 
     @classmethod
     def deactivate_llm_tool(cls, name: str) -> bool:
-        """
-        停用一个已经注册的函数调用工具
+        """停用一个已经注册的函数调用工具
 
         Args:
             name (str): 工具名称
+
         """
+        if cls._context is None:
+            raise ValueError("StarTools not initialized")
         return cls._context.deactivate_llm_tool(name)
 
     @classmethod
     def register_llm_tool(
-        cls, name: str, func_args: list, desc: str, func_obj: Awaitable
+        cls,
+        name: str,
+        func_args: list,
+        desc: str,
+        func_obj: Callable[..., Awaitable[Any]],
     ) -> None:
-        """
-        为函数调用（function-calling/tools-use）添加工具
+        """为函数调用（function-calling/tools-use）添加工具
 
         Args:
             name (str): 工具名称
             func_args (list): 函数参数列表
             desc (str): 工具描述
             func_obj (Awaitable): 函数对象，必须是异步函数
+
         """
+        if cls._context is None:
+            raise ValueError("StarTools not initialized")
         cls._context.register_llm_tool(name, func_args, desc, func_obj)
 
     @classmethod
     def unregister_llm_tool(cls, name: str) -> None:
-        """
-        删除一个函数调用工具
+        """删除一个函数调用工具
         如果再要启用，需要重新注册
 
         Args:
             name (str): 工具名称
+
         """
+        if cls._context is None:
+            raise ValueError("StarTools not initialized")
         cls._context.unregister_llm_tool(name)
 
     @classmethod
-    def get_data_dir(cls, plugin_name: Optional[str] = None) -> Path:
-        """
-        返回插件数据目录的绝对路径。
+    def get_data_dir(cls, plugin_name: str | None = None) -> Path:
+        """返回插件数据目录的绝对路径。
 
         此方法会在 data/plugin_data 目录下为插件创建一个专属的数据目录。如果未提供插件名称，
         会自动从调用栈中获取插件信息。
@@ -165,10 +278,14 @@ class StarTools:
                 - 无法获取调用者模块信息
                 - 无法获取模块的元数据信息
                 - 创建目录失败（权限不足或其他IO错误）
+
         """
         if not plugin_name:
-            frame = inspect.currentframe().f_back
-            module = inspect.getmodule(frame)
+            frame = inspect.currentframe()
+            module = None
+            if frame:
+                frame = frame.f_back
+                module = inspect.getmodule(frame)
 
             if not module:
                 raise RuntimeError("无法获取调用者模块信息")
@@ -180,7 +297,12 @@ class StarTools:
 
             plugin_name = metadata.name
 
-        data_dir = Path("data/plugin_data") / plugin_name
+        if not plugin_name:
+            raise ValueError("无法获取插件名称")
+
+        data_dir = Path(
+            os.path.join(get_astrbot_data_path(), "plugin_data", plugin_name),
+        )
 
         try:
             data_dir.mkdir(parents=True, exist_ok=True)

astrbot/core/star/updator.py

@@ -1,27 +1,26 @@
 import os
-import zipfile
 import shutil
+import zipfile
 
-from ..updator import RepoZipUpdator
-from astrbot.core.utils.io import remove_dir, on_error
-from ..star.star import StarMetadata
 from astrbot.core import logger
+from astrbot.core.utils.astrbot_path import get_astrbot_plugin_path
+from astrbot.core.utils.io import on_error, remove_dir
+
+from ..star.star import StarMetadata
+from ..updator import RepoZipUpdator
 
 
 class PluginUpdator(RepoZipUpdator):
     def __init__(self, repo_mirror: str = "") -> None:
         super().__init__(repo_mirror)
-        self.plugin_store_path = os.path.abspath(
-            os.path.join(
-                os.path.dirname(os.path.abspath(__file__)), "../../../data/plugins"
-            )
-        )
+        self.plugin_store_path = get_astrbot_plugin_path()
 
     def get_plugin_store_path(self) -> str:
         return self.plugin_store_path
 
     async def install(self, repo_url: str, proxy="") -> str:
-        repo_name = self.format_repo_name(repo_url)
+        _, repo_name, _ = self.parse_github_url(repo_url)
+        repo_name = self.format_name(repo_name)
         plugin_path = os.path.join(self.plugin_store_path, repo_name)
         await self.download_from_repo_url(plugin_path, repo_url, proxy)
         self.unzip_file(plugin_path + ".zip", plugin_path)
@@ -34,9 +33,8 @@ class PluginUpdator(RepoZipUpdator):
         if not repo_url:
             raise Exception(f"插件 {plugin.name} 没有指定仓库地址。")
 
-        if proxy:
-            proxy = proxy.removesuffix("/")
-            repo_url = f"{proxy}/{repo_url}"
+        if not plugin.root_dir_name:
+            raise Exception(f"插件 {plugin.name} 的根目录名未指定。")
 
         plugin_path = os.path.join(self.plugin_store_path, plugin.root_dir_name)
 
@@ -47,7 +45,7 @@ class PluginUpdator(RepoZipUpdator):
             remove_dir(plugin_path)
         except BaseException as e:
             logger.error(
-                f"删除旧版本插件 {plugin_path} 文件夹失败: {str(e)}，使用覆盖安装。"
+                f"删除旧版本插件 {plugin_path} 文件夹失败: {e!s}，使用覆盖安装。",
             )
 
         self.unzip_file(plugin_path + ".zip", plugin_path)
@@ -57,7 +55,7 @@ class PluginUpdator(RepoZipUpdator):
     def unzip_file(self, zip_path: str, target_dir: str):
         os.makedirs(target_dir, exist_ok=True)
         update_dir = ""
-        logger.info(f"解压文件: {zip_path}")
+        logger.info(f"正在解压压缩包: {zip_path}")
         with zipfile.ZipFile(zip_path, "r") as z:
             update_dir = z.namelist()[0]
             z.extractall(target_dir)
@@ -67,18 +65,17 @@ class PluginUpdator(RepoZipUpdator):
             if os.path.isdir(os.path.join(target_dir, update_dir, f)):
                 if os.path.exists(os.path.join(target_dir, f)):
                     shutil.rmtree(os.path.join(target_dir, f), onerror=on_error)
-            else:
-                if os.path.exists(os.path.join(target_dir, f)):
-                    os.remove(os.path.join(target_dir, f))
+            elif os.path.exists(os.path.join(target_dir, f)):
+                os.remove(os.path.join(target_dir, f))
             shutil.move(os.path.join(target_dir, update_dir, f), target_dir)
 
         try:
             logger.info(
-                f"删除临时文件: {zip_path} 和 {os.path.join(target_dir, update_dir)}"
+                f"删除临时文件: {zip_path} 和 {os.path.join(target_dir, update_dir)}",
             )
             shutil.rmtree(os.path.join(target_dir, update_dir), onerror=on_error)
             os.remove(zip_path)
         except BaseException:
             logger.warning(
-                f"删除更新文件失败，可以手动删除 {zip_path} 和 {os.path.join(target_dir, update_dir)}"
+                f"删除更新文件失败，可以手动删除 {zip_path} 和 {os.path.join(target_dir, update_dir)}",
             )

astrbot/core/umop_config_router.py

@@ -0,0 +1,106 @@
+from astrbot.core.utils.shared_preferences import SharedPreferences
+
+
+class UmopConfigRouter:
+    """UMOP 配置路由器"""
+
+    def __init__(self, sp: SharedPreferences):
+        self.umop_to_conf_id: dict[str, str] = {}
+        """UMOP 到配置文件 ID 的映射"""
+        self.sp = sp
+
+        self._load_routing_table()
+
+    def _load_routing_table(self):
+        """加载路由表"""
+        # 从 SharedPreferences 中加载 umop_to_conf_id 映射
+        sp_data = self.sp.get(
+            "umop_config_routing",
+            {},
+            scope="global",
+            scope_id="global",
+        )
+        self.umop_to_conf_id = sp_data
+
+    def _is_umo_match(self, p1: str, p2: str) -> bool:
+        """判断 p2 umo 是否逻辑包含于 p1 umo"""
+        p1_ls = p1.split(":")
+        p2_ls = p2.split(":")
+
+        if len(p1_ls) != 3 or len(p2_ls) != 3:
+            return False  # 非法格式
+
+        return all(p == "" or p == "*" or p == t for p, t in zip(p1_ls, p2_ls))
+
+    def get_conf_id_for_umop(self, umo: str) -> str | None:
+        """根据 UMO 获取对应的配置文件 ID
+
+        Args:
+            umo (str): UMO 字符串
+
+        Returns:
+            str | None: 配置文件 ID，如果没有找到则返回 None
+
+        """
+        for pattern, conf_id in self.umop_to_conf_id.items():
+            if self._is_umo_match(pattern, umo):
+                return conf_id
+        return None
+
+    async def update_routing_data(self, new_routing: dict[str, str]):
+        """更新路由表
+
+        Args:
+            new_routing (dict[str, str]): 新的 UMOP 到配置文件 ID 的映射。umo 由三个部分组成 [platform_id]:[message_type]:[session_id]。
+                umop 可以是 "::" (代表所有), 可以是 "[platform_id]::" (代表指定平台下的所有类型消息和会话)。
+
+        Raises:
+            ValueError: 如果 new_routing 中的 key 格式不正确
+
+        """
+        for part in new_routing:
+            if not isinstance(part, str) or len(part.split(":")) != 3:
+                raise ValueError(
+                    "umop keys must be strings in the format [platform_id]:[message_type]:[session_id], with optional wildcards * or empty for all",
+                )
+
+        self.umop_to_conf_id = new_routing
+        await self.sp.global_put("umop_config_routing", self.umop_to_conf_id)
+
+    async def update_route(self, umo: str, conf_id: str):
+        """更新一条路由
+
+        Args:
+            umo (str): UMO 字符串
+            conf_id (str): 配置文件 ID
+
+        Raises:
+            ValueError: 如果 umo 格式不正确
+
+        """
+        if not isinstance(umo, str) or len(umo.split(":")) != 3:
+            raise ValueError(
+                "umop must be a string in the format [platform_id]:[message_type]:[session_id], with optional wildcards * or empty for all",
+            )
+
+        self.umop_to_conf_id[umo] = conf_id
+        await self.sp.global_put("umop_config_routing", self.umop_to_conf_id)
+
+    async def delete_route(self, umo: str):
+        """删除一条路由
+
+        Args:
+            umo (str): 需要删除的 UMO 字符串
+
+        Raises:
+            ValueError: 当 umo 格式不正确时抛出
+        """
+
+        if not isinstance(umo, str) or len(umo.split(":")) != 3:
+            raise ValueError(
+                "umop must be a string in the format [platform_id]:[message_type]:[session_id], with optional wildcards * or empty for all",
+            )
+
+        if umo in self.umop_to_conf_id:
+            del self.umop_to_conf_id[umo]
+            await self.sp.global_put("umop_config_routing", self.umop_to_conf_id)

astrbot/core/updator.py

@@ -1,12 +1,16 @@
 import os
-import psutil
 import sys
 import time
-from .zip_updator import ReleaseInfo, RepoZipUpdator
+
+import psutil
+
 from astrbot.core import logger
 from astrbot.core.config.default import VERSION
+from astrbot.core.utils.astrbot_path import get_astrbot_path
 from astrbot.core.utils.io import download_file
 
+from .zip_updator import ReleaseInfo, RepoZipUpdator
+
 
 class AstrBotUpdator(RepoZipUpdator):
     """AstrBot 更新器，继承自 RepoZipUpdator 类
@@ -16,9 +20,7 @@ class AstrBotUpdator(RepoZipUpdator):
 
     def __init__(self, repo_mirror: str = "") -> None:
         super().__init__(repo_mirror)
-        self.MAIN_PATH = os.path.abspath(
-            os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../")
-        )
+        self.MAIN_PATH = get_astrbot_path()
         self.ASTRBOT_RELEASE_API = "https://api.soulter.top/releases"
 
     def terminate_child_processes(self):
@@ -45,20 +47,40 @@ class AstrBotUpdator(RepoZipUpdator):
     def _reboot(self, delay: int = 3):
         """重启当前程序
         在指定的延迟后，终止所有子进程并重新启动程序
+        这里只能使用 os.exec* 来重启程序
         """
-        py = sys.executable
         time.sleep(delay)
         self.terminate_child_processes()
-        py = py.replace(" ", "\\ ")
+        if os.name == "nt":
+            py = f'"{sys.executable}"'
+        else:
+            py = sys.executable
+
         try:
-            os.execl(py, py, *sys.argv)
+            if "astrbot" in os.path.basename(sys.argv[0]):  # 兼容cli
+                if os.name == "nt":
+                    args = [f'"{arg}"' if " " in arg else arg for arg in sys.argv[1:]]
+                else:
+                    args = sys.argv[1:]
+                os.execl(sys.executable, py, "-m", "astrbot.cli.__main__", *args)
+            else:
+                os.execl(sys.executable, py, *sys.argv)
         except Exception as e:
             logger.error(f"重启失败（{py}, {e}），请尝试手动重启。")
             raise e
 
-    async def check_update(self, url: str, current_version: str) -> ReleaseInfo:
+    async def check_update(
+        self,
+        url: str,
+        current_version: str,
+        consider_prerelease: bool = True,
+    ) -> ReleaseInfo:
         """检查更新"""
-        return await super().check_update(self.ASTRBOT_RELEASE_API, VERSION)
+        return await super().check_update(
+            self.ASTRBOT_RELEASE_API,
+            VERSION,
+            consider_prerelease,
+        )
 
     async def get_releases(self) -> list:
         return await self.fetch_release_info(self.ASTRBOT_RELEASE_API)
@@ -67,6 +89,9 @@ class AstrBotUpdator(RepoZipUpdator):
         update_data = await self.fetch_release_info(self.ASTRBOT_RELEASE_API, latest)
         file_url = None
 
+        if os.environ.get("ASTRBOT_CLI"):
+            raise Exception("不支持更新CLI启动的AstrBot")  # 避免版本管理混乱
+
         if latest:
             latest_version = update_data[0]["tag_name"]
             if self.compare_version(VERSION, latest_version) >= 0:
@@ -74,7 +99,6 @@ class AstrBotUpdator(RepoZipUpdator):
             file_url = update_data[0]["zipball_url"]
         elif str(version).startswith("v"):
             # 更新到指定版本
-            logger.info(f"正在更新到指定版本: {version}")
             for data in update_data:
                 if data["tag_name"] == version:
                     file_url = data["zipball_url"]
@@ -83,8 +107,8 @@ class AstrBotUpdator(RepoZipUpdator):
         else:
             if len(str(version)) != 40:
                 raise Exception("commit hash 长度不正确，应为 40")
-            logger.info(f"正在尝试更新到指定 commit: {version}")
-            file_url = "https://github.com/Soulter/AstrBot/archive/" + version + ".zip"
+            file_url = f"https://github.com/AstrBotDevs/AstrBot/archive/{version}.zip"
+        logger.info(f"准备更新至指定版本的 AstrBot Core: {version}")
 
         if proxy:
             proxy = proxy.removesuffix("/")
@@ -92,6 +116,7 @@ class AstrBotUpdator(RepoZipUpdator):
 
         try:
             await download_file(file_url, "temp.zip")
+            logger.info("下载 AstrBot Core 更新文件完成，正在执行解压...")
             self.unzip_file("temp.zip", self.MAIN_PATH)
         except BaseException as e:
             raise e

astrbot/core/utils/astrbot_path.py

@@ -0,0 +1,39 @@
+"""Astrbot统一路径获取
+
+项目路径：固定为源码所在路径
+根目录路径：默认为当前工作目录，可通过环境变量 ASTRBOT_ROOT 指定
+数据目录路径：固定为根目录下的 data 目录
+配置文件路径：固定为数据目录下的 config 目录
+插件目录路径：固定为数据目录下的 plugins 目录
+"""
+
+import os
+
+
+def get_astrbot_path() -> str:
+    """获取Astrbot项目路径"""
+    return os.path.realpath(
+        os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../../"),
+    )
+
+
+def get_astrbot_root() -> str:
+    """获取Astrbot根目录路径"""
+    if path := os.environ.get("ASTRBOT_ROOT"):
+        return os.path.realpath(path)
+    return os.path.realpath(os.getcwd())
+
+
+def get_astrbot_data_path() -> str:
+    """获取Astrbot数据目录路径"""
+    return os.path.realpath(os.path.join(get_astrbot_root(), "data"))
+
+
+def get_astrbot_config_path() -> str:
+    """获取Astrbot配置文件路径"""
+    return os.path.realpath(os.path.join(get_astrbot_data_path(), "config"))
+
+
+def get_astrbot_plugin_path() -> str:
+    """获取Astrbot插件目录路径"""
+    return os.path.realpath(os.path.join(get_astrbot_data_path(), "plugins"))