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

astrbot/dashboard/routes/plugin.py

@@ -1,22 +1,23 @@
-import traceback
-import aiohttp
+import json
 import os
-
 import ssl
-import certifi
+import traceback
+from datetime import datetime
 
-from .route import Route, Response, RouteContext
-from astrbot.core import logger
+import aiohttp
+import certifi
 from quart import request
-from astrbot.core.star.star_manager import PluginManager
+
+from astrbot.core import DEMO_MODE, file_token_service, logger
 from astrbot.core.core_lifecycle import AstrBotCoreLifecycle
-from astrbot.core.star.star_handler import star_handlers_registry
 from astrbot.core.star.filter.command import CommandFilter
 from astrbot.core.star.filter.command_group import CommandGroupFilter
 from astrbot.core.star.filter.permission import PermissionTypeFilter
 from astrbot.core.star.filter.regex import RegexFilter
-from astrbot.core.star.star_handler import EventType
-from astrbot.core import DEMO_MODE
+from astrbot.core.star.star_handler import EventType, star_handlers_registry
+from astrbot.core.star.star_manager import PluginManager
+
+from .route import Response, Route, RouteContext
 
 
 class PluginRoute(Route):
@@ -38,8 +39,6 @@ class PluginRoute(Route):
             "/plugin/on": ("POST", self.on_plugin),
             "/plugin/reload": ("POST", self.reload_plugins),
             "/plugin/readme": ("GET", self.get_plugin_readme),
-            "/plugin/platform_enable/get": ("GET", self.get_plugin_platform_enable),
-            "/plugin/platform_enable/set": ("POST", self.set_plugin_platform_enable),
         }
         self.core_lifecycle = core_lifecycle
         self.plugin_manager = plugin_manager
@@ -54,6 +53,8 @@ class PluginRoute(Route):
             EventType.OnAfterMessageSentEvent: "发送消息后",
         }
 
+        self._logo_cache = {}
+
     async def reload_plugins(self):
         if DEMO_MODE:
             return (
@@ -75,34 +76,185 @@ class PluginRoute(Route):
 
     async def get_online_plugins(self):
         custom = request.args.get("custom_registry")
+        force_refresh = request.args.get("force_refresh", "false").lower() == "true"
+
+        cache_file = "data/plugins.json"
 
         if custom:
             urls = [custom]
         else:
-            urls = ["https://api.soulter.top/astrbot/plugins"]
-
-        # 新增：创建 SSL 上下文，使用 certifi 提供的根证书
+            urls = [
+                "https://api.soulter.top/astrbot/plugins",
+                "https://github.com/AstrBotDevs/AstrBot_Plugins_Collection/raw/refs/heads/main/plugin_cache_original.json",
+            ]
+
+        # 如果不是强制刷新，先检查缓存是否有效
+        cached_data = None
+        if not force_refresh:
+            # 先检查MD5是否匹配，如果匹配则使用缓存
+            if await self._is_cache_valid(cache_file):
+                cached_data = self._load_plugin_cache(cache_file)
+                if cached_data:
+                    logger.debug("缓存MD5匹配，使用缓存的插件市场数据")
+                    return Response().ok(cached_data).__dict__
+
+        # 尝试获取远程数据
+        remote_data = None
         ssl_context = ssl.create_default_context(cafile=certifi.where())
         connector = aiohttp.TCPConnector(ssl=ssl_context)
+
         for url in urls:
             try:
-                async with aiohttp.ClientSession(
-                    trust_env=True, connector=connector
-                ) as session:
-                    async with session.get(url) as response:
-                        if response.status == 200:
-                            result = await response.json()
-                            return Response().ok(result).__dict__
-                        else:
-                            logger.error(f"请求 {url} 失败，状态码：{response.status}")
+                async with (
+                    aiohttp.ClientSession(
+                        trust_env=True,
+                        connector=connector,
+                    ) as session,
+                    session.get(url) as response,
+                ):
+                    if response.status == 200:
+                        remote_data = await response.json()
+
+                        # 检查远程数据是否为空
+                        if not remote_data or (
+                            isinstance(remote_data, dict) and len(remote_data) == 0
+                        ):
+                            logger.warning(f"远程插件市场数据为空: {url}")
+                            continue  # 继续尝试其他URL或使用缓存
+
+                        logger.info("成功获取远程插件市场数据")
+                        # 获取最新的MD5并保存到缓存
+                        current_md5 = await self._get_remote_md5()
+                        self._save_plugin_cache(
+                            cache_file,
+                            remote_data,
+                            current_md5,
+                        )
+                        return Response().ok(remote_data).__dict__
+                    logger.error(f"请求 {url} 失败，状态码：{response.status}")
             except Exception as e:
                 logger.error(f"请求 {url} 失败，错误：{e}")
 
-        return Response().error("获取插件列表失败").__dict__
+        # 如果远程获取失败，尝试使用缓存数据
+        if not cached_data:
+            cached_data = self._load_plugin_cache(cache_file)
+
+        if cached_data:
+            logger.warning("远程插件市场数据获取失败，使用缓存数据")
+            return Response().ok(cached_data, "使用缓存数据，可能不是最新版本").__dict__
+
+        return Response().error("获取插件列表失败，且没有可用的缓存数据").__dict__
+
+    async def _is_cache_valid(self, cache_file: str) -> bool:
+        """检查缓存是否有效（基于MD5）"""
+        try:
+            if not os.path.exists(cache_file):
+                return False
+
+            # 加载缓存文件
+            with open(cache_file, encoding="utf-8") as f:
+                cache_data = json.load(f)
+
+            cached_md5 = cache_data.get("md5")
+            if not cached_md5:
+                logger.debug("缓存文件中没有MD5信息")
+                return False
+
+            # 获取远程MD5
+            remote_md5 = await self._get_remote_md5()
+            if not remote_md5:
+                logger.warning("无法获取远程MD5，将使用缓存")
+                return True  # 如果无法获取远程MD5，认为缓存有效
+
+            is_valid = cached_md5 == remote_md5
+            logger.debug(
+                f"插件数据MD5: 本地={cached_md5}, 远程={remote_md5}, 有效={is_valid}",
+            )
+            return is_valid
+
+        except Exception as e:
+            logger.warning(f"检查缓存有效性失败: {e}")
+            return False
+
+    async def _get_remote_md5(self) -> str:
+        """获取远程插件数据的MD5"""
+        try:
+            ssl_context = ssl.create_default_context(cafile=certifi.where())
+            connector = aiohttp.TCPConnector(ssl=ssl_context)
+
+            async with (
+                aiohttp.ClientSession(
+                    trust_env=True,
+                    connector=connector,
+                ) as session,
+                session.get(
+                    "https://api.soulter.top/astrbot/plugins-md5",
+                ) as response,
+            ):
+                if response.status == 200:
+                    data = await response.json()
+                    return data.get("md5", "")
+                logger.error(f"获取MD5失败，状态码：{response.status}")
+                return ""
+        except Exception as e:
+            logger.error(f"获取远程MD5失败: {e}")
+            return ""
+
+    def _load_plugin_cache(self, cache_file: str):
+        """加载本地缓存的插件市场数据"""
+        try:
+            if os.path.exists(cache_file):
+                with open(cache_file, encoding="utf-8") as f:
+                    cache_data = json.load(f)
+                    # 检查缓存是否有效
+                    if "data" in cache_data and "timestamp" in cache_data:
+                        logger.debug(
+                            f"加载缓存文件: {cache_file}, 缓存时间: {cache_data['timestamp']}",
+                        )
+                        return cache_data["data"]
+        except Exception as e:
+            logger.warning(f"加载插件市场缓存失败: {e}")
+        return None
+
+    def _save_plugin_cache(self, cache_file: str, data, md5: str | None = None):
+        """保存插件市场数据到本地缓存"""
+        try:
+            # 确保目录存在
+            os.makedirs(os.path.dirname(cache_file), exist_ok=True)
+
+            cache_data = {
+                "timestamp": datetime.now().isoformat(),
+                "data": data,
+                "md5": md5 or "",
+            }
+
+            with open(cache_file, "w", encoding="utf-8") as f:
+                json.dump(cache_data, f, ensure_ascii=False, indent=2)
+            logger.debug(f"插件市场数据已缓存到: {cache_file}, MD5: {md5}")
+        except Exception as e:
+            logger.warning(f"保存插件市场缓存失败: {e}")
+
+    async def get_plugin_logo_token(self, logo_path: str):
+        try:
+            if token := self._logo_cache.get(logo_path):
+                if not await file_token_service.check_token_expired(token):
+                    return self._logo_cache[logo_path]
+            token = await file_token_service.register_file(logo_path, timeout=300)
+            self._logo_cache[logo_path] = token
+            return token
+        except Exception as e:
+            logger.warning(f"获取插件 Logo 失败: {e}")
+            return None
 
     async def get_plugins(self):
         _plugin_resp = []
+        plugin_name = request.args.get("name")
         for plugin in self.plugin_manager.context.get_all_stars():
+            if plugin_name and plugin.name != plugin_name:
+                continue
+            logo_url = None
+            if plugin.logo_path:
+                logo_url = await self.get_plugin_logo_token(plugin.logo_path)
             _t = {
                 "name": plugin.name,
                 "repo": "" if plugin.repo is None else plugin.repo,
@@ -113,8 +265,10 @@ class PluginRoute(Route):
                 "activated": plugin.activated,
                 "online_vesion": "",
                 "handlers": await self.get_plugin_handlers_info(
-                    plugin.star_handler_full_names
+                    plugin.star_handler_full_names,
                 ),
+                "display_name": plugin.display_name,
+                "logo": f"/api/file/{logo_url}" if logo_url else None,
             }
             _plugin_resp.append(_t)
         return (
@@ -130,13 +284,15 @@ class PluginRoute(Route):
         for handler_full_name in handler_full_names:
             info = {}
             handler = star_handlers_registry.star_handlers_map.get(
-                handler_full_name, None
+                handler_full_name,
+                None,
             )
             if handler is None:
                 continue
             info["event_type"] = handler.event_type.name
             info["event_type_h"] = self.translated_event_type.get(
-                handler.event_type, handler.event_type.name
+                handler.event_type,
+                handler.event_type.name,
             )
             info["handler_full_name"] = handler.handler_full_name
             info["desc"] = handler.desc
@@ -145,9 +301,7 @@ class PluginRoute(Route):
             if handler.event_type == EventType.AdapterMessageEvent:
                 # 处理平台适配器消息事件
                 has_admin = False
-                for (
-                    filter
-                ) in (
+                for filter in (
                     handler.event_filters
                 ):  # 正常handler就只有 1~2 个 filter，因此这里时间复杂度不会太高
                     if isinstance(filter, CommandFilter):
@@ -156,29 +310,13 @@ class PluginRoute(Route):
                             f"{filter.parent_command_names[0]} {filter.command_name}"
                         )
                         info["cmd"] = info["cmd"].strip()
-                        if (
-                            self.core_lifecycle.astrbot_config["wake_prefix"]
-                            and len(self.core_lifecycle.astrbot_config["wake_prefix"])
-                            > 0
-                        ):
-                            info["cmd"] = (
-                                f"{self.core_lifecycle.astrbot_config['wake_prefix'][0]}{info['cmd']}"
-                            )
                     elif isinstance(filter, CommandGroupFilter):
                         info["type"] = "指令组"
                         info["cmd"] = filter.get_complete_command_names()[0]
                         info["cmd"] = info["cmd"].strip()
                         info["sub_command"] = filter.print_cmd_tree(
-                            filter.sub_command_filters
+                            filter.sub_command_filters,
                         )
-                        if (
-                            self.core_lifecycle.astrbot_config["wake_prefix"]
-                            and len(self.core_lifecycle.astrbot_config["wake_prefix"])
-                            > 0
-                        ):
-                            info["cmd"] = (
-                                f"{self.core_lifecycle.astrbot_config['wake_prefix'][0]}{info['cmd']}"
-                            )
                     elif isinstance(filter, RegexFilter):
                         info["type"] = "正则匹配"
                         info["cmd"] = filter.regex_str
@@ -257,9 +395,15 @@ class PluginRoute(Route):
 
         post_data = await request.json
         plugin_name = post_data["name"]
+        delete_config = post_data.get("delete_config", False)
+        delete_data = post_data.get("delete_data", False)
         try:
             logger.info(f"正在卸载插件 {plugin_name}")
-            await self.plugin_manager.uninstall_plugin(plugin_name)
+            await self.plugin_manager.uninstall_plugin(
+                plugin_name,
+                delete_config=delete_config,
+                delete_data=delete_data,
+            )
             logger.info(f"卸载插件 {plugin_name} 成功")
             return Response().ok(None, "卸载成功").__dict__
         except Exception as e:
@@ -343,7 +487,8 @@ class PluginRoute(Route):
             return Response().error(f"插件 {plugin_name} 不存在").__dict__
 
         plugin_dir = os.path.join(
-            self.plugin_manager.plugin_store_path, plugin_obj.root_dir_name
+            self.plugin_manager.plugin_store_path,
+            plugin_obj.root_dir_name,
         )
 
         if not os.path.isdir(plugin_dir):
@@ -357,7 +502,7 @@ class PluginRoute(Route):
             return Response().error(f"插件 {plugin_name} 没有README文件").__dict__
 
         try:
-            with open(readme_path, "r", encoding="utf-8") as f:
+            with open(readme_path, encoding="utf-8") as f:
                 readme_content = f.read()
 
             return (
@@ -367,91 +512,4 @@ class PluginRoute(Route):
             )
         except Exception as e:
             logger.error(f"/api/plugin/readme: {traceback.format_exc()}")
-            return Response().error(f"读取README文件失败: {str(e)}").__dict__
-
-    async def get_plugin_platform_enable(self):
-        """获取插件在各平台的可用性配置"""
-        try:
-            platform_enable = self.core_lifecycle.astrbot_config.get(
-                "platform_settings", {}
-            ).get("plugin_enable", {})
-
-            # 获取所有可用平台
-            platforms = []
-
-            for platform in self.core_lifecycle.astrbot_config.get("platform", []):
-                platform_type = platform.get("type", "")
-                platform_id = platform.get("id", "")
-
-                platforms.append(
-                    {
-                        "name": platform_id,  # 使用type作为name，这是系统内部使用的平台名称
-                        "id": platform_id,  # 保留id字段以便前端可以显示
-                        "type": platform_type,
-                        "display_name": f"{platform_type}({platform_id})",
-                    }
-                )
-
-            adjusted_platform_enable = {}
-            for platform_id, plugins in platform_enable.items():
-                adjusted_platform_enable[platform_id] = plugins
-
-            # 获取所有插件，包括系统内部插件
-            plugins = []
-            for plugin in self.plugin_manager.context.get_all_stars():
-                plugins.append(
-                    {
-                        "name": plugin.name,
-                        "desc": plugin.desc,
-                        "reserved": plugin.reserved,  # 添加reserved标志
-                    }
-                )
-
-            logger.debug(
-                f"获取插件平台配置: 原始配置={platform_enable}, 调整后={adjusted_platform_enable}"
-            )
-
-            return (
-                Response()
-                .ok(
-                    {
-                        "platforms": platforms,
-                        "plugins": plugins,
-                        "platform_enable": adjusted_platform_enable,
-                    }
-                )
-                .__dict__
-            )
-        except Exception as e:
-            logger.error(f"/api/plugin/platform_enable/get: {traceback.format_exc()}")
-            return Response().error(str(e)).__dict__
-
-    async def set_plugin_platform_enable(self):
-        """设置插件在各平台的可用性配置"""
-        if DEMO_MODE:
-            return (
-                Response()
-                .error("You are not permitted to do this operation in demo mode")
-                .__dict__
-            )
-
-        try:
-            data = await request.json
-            platform_enable = data.get("platform_enable", {})
-
-            # 更新配置
-            config = self.core_lifecycle.astrbot_config
-            platform_settings = config.get("platform_settings", {})
-            platform_settings["plugin_enable"] = platform_enable
-            config["platform_settings"] = platform_settings
-            config.save_config()
-
-            # 更新插件的平台兼容性缓存
-            await self.plugin_manager.update_all_platform_compatibility()
-
-            logger.info(f"插件平台可用性配置已更新: {platform_enable}")
-
-            return Response().ok(None, "插件平台可用性配置已更新").__dict__
-        except Exception as e:
-            logger.error(f"/api/plugin/platform_enable/set: {traceback.format_exc()}")
-            return Response().error(str(e)).__dict__
+            return Response().error(f"读取README文件失败: {e!s}").__dict__

astrbot/dashboard/routes/route.py

@@ -1,7 +1,9 @@
-from astrbot.core.config.astrbot_config import AstrBotConfig
 from dataclasses import dataclass
+
 from quart import Quart
 
+from astrbot.core.config.astrbot_config import AstrBotConfig
+
 
 @dataclass
 class RouteContext:
@@ -15,23 +17,41 @@ class Route:
         self.config = context.config
 
     def register_routes(self):
-        for route, (method, func) in self.routes.items():
-            self.app.add_url_rule(f"/api{route}", view_func=func, methods=[method])
+        def _add_rule(path, method, func):
+            # 统一添加 /api 前缀
+            full_path = f"/api{path}"
+            self.app.add_url_rule(full_path, view_func=func, methods=[method])
+
+        # 兼容字典和列表两种格式
+        routes_to_register = (
+            self.routes.items() if isinstance(self.routes, dict) else self.routes
+        )
+
+        for route, definition in routes_to_register:
+            # 兼容一个路由多个方法
+            if isinstance(definition, list):
+                for method, func in definition:
+                    _add_rule(route, method, func)
+            else:
+                method, func = definition
+                _add_rule(route, method, func)
 
 
 @dataclass
 class Response:
-    status: str = None
-    message: str = None
-    data: dict = None
+    status: str | None = None
+    message: str | None = None
+    data: dict | list | None = None
 
     def error(self, message: str):
         self.status = "error"
         self.message = message
         return self
 
-    def ok(self, data: dict = {}, message: str = None):
+    def ok(self, data: dict | list | None = None, message: str | None = None):
         self.status = "ok"
+        if data is None:
+            data = {}
         self.data = data
         self.message = message
         return self