From c7937c099a0cb48dbafbe4dc9991dd3e83d26019 Mon Sep 17 00:00:00 2001 From: YokiiroBW Date: Mon, 6 Jul 2026 04:00:59 +0800 Subject: [PATCH] =?UTF-8?q?S106=20AstrBot=E8=BF=90=E8=A1=8C=E6=97=B6?= =?UTF-8?q?=E6=B3=A8=E5=86=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- adapters/__init__.py | 12 +++- adapters/astrbot_adapter.py | 108 +++++++++++++++++++++++++++++++- main.py | 19 +++++- tests/test_plugin_entrypoint.py | 25 +++++++- tests/test_route_registry.py | 35 +++++++++++ 5 files changed, 195 insertions(+), 4 deletions(-) diff --git a/adapters/__init__.py b/adapters/__init__.py index 04a0b86..bebd3b2 100644 --- a/adapters/__init__.py +++ b/adapters/__init__.py @@ -1,6 +1,13 @@ """Runtime adapters for AstrBot, chat platforms, and Web UI integration.""" -from adapters.astrbot_adapter import dispatch_extension_request, resolve_route, runtime_route_table +from adapters.astrbot_adapter import ( + dispatch_extension_request, + register_astrbot_runtime, + resolve_route, + runtime_health, + runtime_registration_manifest, + runtime_route_table, +) from adapters.onebot11_adapter import handle_message_event as handle_onebot11_message_event from adapters.webui_adapter import get_web_mount_manifest, resolve_web_asset from adapters.wechat_adapter import handle_message_event as handle_wechat_message_event @@ -10,7 +17,10 @@ __all__ = [ "get_web_mount_manifest", "handle_onebot11_message_event", "handle_wechat_message_event", + "register_astrbot_runtime", "resolve_route", "resolve_web_asset", + "runtime_health", + "runtime_registration_manifest", "runtime_route_table", ] diff --git a/adapters/astrbot_adapter.py b/adapters/astrbot_adapter.py index f5763a4..80c4b3b 100644 --- a/adapters/astrbot_adapter.py +++ b/adapters/astrbot_adapter.py @@ -13,7 +13,7 @@ from dataclasses import dataclass from typing import Any, Callable from backend.dto.common import ErrorCode, error_response -from backend.route_registry import ROUTES, RouteSpec +from backend.route_registry import ROUTES, RouteSpec, assert_unique_routes from backend.services.ui_service import API_BASE from core.identity import RequestContext @@ -74,6 +74,78 @@ def runtime_route_table() -> list[dict[str, Any]]: ] +def runtime_registration_manifest() -> dict[str, Any]: + return { + "plugin_name": "astrbot_plugin_imagestudio", + "api_base": API_BASE, + "dispatch_handler": "adapters.astrbot_adapter.dispatch_extension_request", + "web_asset_handler": "adapters.webui_adapter.resolve_web_asset", + "extension_routes": runtime_route_table(), + "web_mounts": [ + { + "name": "standalone_web", + "path": f"{API_BASE}/web", + "handler": "adapters.webui_adapter.resolve_web_asset", + } + ], + "health": runtime_health(), + } + + +def runtime_health() -> dict[str, Any]: + errors: list[dict[str, Any]] = [] + try: + assert_unique_routes() + except RuntimeError as exc: + errors.append({"code": "DUPLICATE_ROUTE", "message": str(exc)}) + importable = 0 + for route in ROUTES: + try: + _load_handler(route.handler) + importable += 1 + except Exception as exc: + errors.append( + { + "code": "HANDLER_IMPORT_FAILED", + "route": route.endpoint, + "handler": route.handler, + "message": str(exc), + } + ) + return { + "ok": not errors, + "route_count": len(ROUTES), + "importable_handlers": importable, + "errors": errors, + } + + +def register_astrbot_runtime(runtime: Any, registration: dict[str, Any] | None = None) -> dict[str, Any]: + manifest = registration or runtime_registration_manifest() + route_count = 0 + web_mount_count = 0 + missing: list[str] = [] + for route in manifest["extension_routes"]: + if _register_route(runtime, route): + route_count += 1 + else: + missing.append("register_extension_route") + break + for mount in manifest["web_mounts"]: + if _register_web_mount(runtime, mount): + web_mount_count += 1 + else: + missing.append("register_web_mount") + break + return { + "registered": not missing, + "routes_registered": route_count, + "web_mounts_registered": web_mount_count, + "missing_capabilities": sorted(set(missing)), + "health": manifest["health"], + } + + def dispatch_extension_request( ctx: RequestContext, method: str, @@ -93,6 +165,40 @@ def dispatch_extension_request( return match.handler(*_handler_args(match, ctx, query or {}, payload or {})) +def _register_route(runtime: Any, route: dict[str, Any]) -> bool: + handler = _load_handler(str(route["handler"])) + for method_name in ("register_extension_route", "register_route", "add_route"): + callback = getattr(runtime, method_name, None) + if not callable(callback): + continue + try: + callback( + method=route["method"], + path=route["path"], + handler=handler, + permission=route["permission"], + endpoint=route["endpoint"], + ) + except TypeError: + callback(route["method"], route["path"], handler) + return True + return False + + +def _register_web_mount(runtime: Any, mount: dict[str, Any]) -> bool: + handler = _load_handler(str(mount["handler"])) + for method_name in ("register_web_mount", "mount_web", "add_web_mount"): + callback = getattr(runtime, method_name, None) + if not callable(callback): + continue + try: + callback(name=mount["name"], path=mount["path"], handler=handler) + except TypeError: + callback(mount["path"], handler) + return True + return False + + def _match_endpoint(pattern: str, endpoint: str) -> dict[str, str] | None: param_names = re.findall(r"\{([^{}]+)\}", pattern) regex = "^" + re.sub(r"\{([^{}]+)\}", r"([^/]+)", pattern) + "$" diff --git a/main.py b/main.py index f74ad48..47c2e40 100644 --- a/main.py +++ b/main.py @@ -8,7 +8,13 @@ from __future__ import annotations from typing import Any -from adapters.astrbot_adapter import dispatch_extension_request, runtime_route_table +from adapters.astrbot_adapter import ( + dispatch_extension_request, + register_astrbot_runtime, + runtime_health, + runtime_registration_manifest, + runtime_route_table, +) from adapters.webui_adapter import get_web_mount_manifest from backend.services.ui_service import API_BASE from core.identity import RequestContext @@ -19,14 +25,25 @@ PLUGIN_NAME = "astrbot_plugin_imagestudio" def get_plugin_manifest() -> dict[str, Any]: web_manifest = get_web_mount_manifest() + runtime = runtime_registration_manifest() return { "plugin_name": PLUGIN_NAME, "api_base": API_BASE, "web": web_manifest, "routes": runtime_route_table(), + "runtime": runtime, + "health": runtime["health"], } +def register_plugin(runtime: Any) -> dict[str, Any]: + return register_astrbot_runtime(runtime, runtime_registration_manifest()) + + +def get_runtime_health() -> dict[str, Any]: + return runtime_health() + + def dispatch_web_request( ctx: RequestContext, method: str, diff --git a/tests/test_plugin_entrypoint.py b/tests/test_plugin_entrypoint.py index 087015c..7bd8936 100644 --- a/tests/test_plugin_entrypoint.py +++ b/tests/test_plugin_entrypoint.py @@ -2,8 +2,9 @@ from __future__ import annotations import unittest +from backend.route_registry import ROUTES from core.identity import RequestContext -from main import PLUGIN_NAME, dispatch_web_request, get_plugin_manifest +from main import PLUGIN_NAME, dispatch_web_request, get_plugin_manifest, get_runtime_health, register_plugin class PluginEntrypointTests(unittest.TestCase): @@ -14,6 +15,8 @@ class PluginEntrypointTests(unittest.TestCase): self.assertTrue(manifest["api_base"].endswith("astrbot_plugin_imagestudio")) self.assertIn("web", manifest) self.assertTrue(any(route["endpoint"] == "dashboard/summary" for route in manifest["routes"])) + self.assertTrue(manifest["runtime"]["health"]["ok"]) + self.assertEqual(manifest["health"]["route_count"], len(ROUTES)) def test_dispatch_web_request_delegates_to_adapter(self): ctx = RequestContext.from_astrbot(username="admin", user_id="user_001") @@ -27,6 +30,26 @@ class PluginEntrypointTests(unittest.TestCase): self.assertTrue(response["ok"]) self.assertEqual(response["data"]["plugin_name"], PLUGIN_NAME) + def test_register_plugin_delegates_to_runtime_registration(self): + class FakeRuntime: + def __init__(self): + self.routes = [] + self.mounts = [] + + def register_extension_route(self, **kwargs): + self.routes.append(kwargs) + + def register_web_mount(self, **kwargs): + self.mounts.append(kwargs) + + runtime = FakeRuntime() + result = register_plugin(runtime) + + self.assertTrue(result["registered"]) + self.assertEqual(len(runtime.routes), len(ROUTES)) + self.assertEqual(len(runtime.mounts), 1) + self.assertTrue(get_runtime_health()["ok"]) + if __name__ == "__main__": unittest.main() diff --git a/tests/test_route_registry.py b/tests/test_route_registry.py index 4ba73c8..8897f09 100644 --- a/tests/test_route_registry.py +++ b/tests/test_route_registry.py @@ -8,7 +8,10 @@ from pathlib import Path from adapters.astrbot_adapter import ( dispatch_extension_request, normalize_extension_path, + register_astrbot_runtime, resolve_route, + runtime_health, + runtime_registration_manifest, runtime_route_table, ) from adapters.webui_adapter import get_web_mount_manifest, resolve_web_asset @@ -131,6 +134,38 @@ class RouteRegistryTests(unittest.TestCase): table = runtime_route_table() self.assertTrue(any(route["path"].endswith("/dashboard/summary") for route in table)) + def test_runtime_registration_manifest_and_health_are_stable(self): + registration = runtime_registration_manifest() + health = runtime_health() + + self.assertEqual(registration["plugin_name"], "astrbot_plugin_imagestudio") + self.assertTrue(registration["api_base"].endswith("astrbot_plugin_imagestudio")) + self.assertTrue(registration["web_mounts"][0]["path"].endswith("/web")) + self.assertTrue(health["ok"]) + self.assertEqual(health["route_count"], len(ROUTES)) + self.assertEqual(health["importable_handlers"], len(ROUTES)) + + def test_register_astrbot_runtime_calls_host_registration_methods(self): + class FakeRuntime: + def __init__(self): + self.routes = [] + self.mounts = [] + + def register_extension_route(self, **kwargs): + self.routes.append(kwargs) + + def register_web_mount(self, **kwargs): + self.mounts.append(kwargs) + + runtime = FakeRuntime() + result = register_astrbot_runtime(runtime) + + self.assertTrue(result["registered"]) + self.assertEqual(result["routes_registered"], len(ROUTES)) + self.assertEqual(result["web_mounts_registered"], 1) + self.assertTrue(callable(runtime.routes[0]["handler"])) + self.assertTrue(callable(runtime.mounts[0]["handler"])) + def test_astrbot_adapter_dispatches_pure_route_handlers(self): ctx = RequestContext.from_astrbot(username="admin", user_id="user_001", permissions={"can_manage_config"})