|
|
@@ -0,0 +1,172 @@
|
|
|
+"""In-process dispatch to Hermes' own dashboard REST handlers (Yaoyao embedded mode).
|
|
|
+
|
|
|
+Yaoyao used to call a separately running Hermes dashboard over HTTP. The embedded runtime has
|
|
|
+no ASGI server: hermes_service.py shims FastAPI so the router modules import as plain functions
|
|
|
+and records each decorated route. ``call`` matches a method + path against those routes and
|
|
|
+invokes the native handler with path, query and body arguments, so responses keep the exact
|
|
|
+shapes the dashboard returned. One service process serves one Hermes home, so the ``profile``
|
|
|
+query parameter is resolved by the caller choosing the process, never by the handler.
|
|
|
+"""
|
|
|
+import asyncio
|
|
|
+import inspect
|
|
|
+import re
|
|
|
+import types
|
|
|
+import typing
|
|
|
+from typing import Any
|
|
|
+
|
|
|
+ROUTER_MODULES = (
|
|
|
+ "hermes_cli.web_routers.sessions",
|
|
|
+ "hermes_cli.web_routers.profiles",
|
|
|
+ "hermes_cli.web_routers.config_env",
|
|
|
+ "hermes_cli.web_routers.models",
|
|
|
+ "hermes_cli.web_routers.files",
|
|
|
+)
|
|
|
+_loaded = False
|
|
|
+_compiled: list[tuple[str, re.Pattern, list[str], Any]] = []
|
|
|
+
|
|
|
+
|
|
|
+def _load(routes):
|
|
|
+ global _loaded
|
|
|
+ if _loaded:
|
|
|
+ return
|
|
|
+ import importlib
|
|
|
+ import os
|
|
|
+ from pathlib import Path
|
|
|
+ home = Path(os.environ["HERMES_HOME"])
|
|
|
+ if not (home / "state.db").exists():
|
|
|
+ # The dashboard expects its gateway to have created the store; the embedded home creates it here.
|
|
|
+ from hermes_state import SessionDB
|
|
|
+ SessionDB(db_path=home / "state.db").close()
|
|
|
+ for name in ROUTER_MODULES:
|
|
|
+ importlib.import_module(name)
|
|
|
+ for method, template, fn in routes:
|
|
|
+ names = re.findall(r"{([A-Za-z_][A-Za-z0-9_]*)(?::path)?}", template)
|
|
|
+ pattern = re.escape(template)
|
|
|
+ for param in names:
|
|
|
+ pattern = pattern.replace(re.escape("{" + param + ":path}"), "(?P<%s>.+)" % param)
|
|
|
+ pattern = pattern.replace(re.escape("{" + param + "}"), "(?P<%s>[^/]+)" % param)
|
|
|
+ # Static routes (``/api/sessions/search``) win over templates (``/api/sessions/{id}``).
|
|
|
+ _compiled.append((method, re.compile("^" + pattern + "$"), names, fn))
|
|
|
+ _compiled.sort(key=lambda item: len(item[2]))
|
|
|
+ _loaded = True
|
|
|
+
|
|
|
+
|
|
|
+class _Request:
|
|
|
+ def __init__(self, query, body):
|
|
|
+ self.headers = {}
|
|
|
+ self.cookies = {}
|
|
|
+ self.query_params = query
|
|
|
+ self.client = types.SimpleNamespace(host="127.0.0.1", port=0)
|
|
|
+ self.url = types.SimpleNamespace(path="", query="")
|
|
|
+ self.state = types.SimpleNamespace()
|
|
|
+ self._body = body
|
|
|
+
|
|
|
+ async def json(self):
|
|
|
+ return self._body
|
|
|
+
|
|
|
+
|
|
|
+def _base_types(annotation):
|
|
|
+ if annotation is inspect.Parameter.empty:
|
|
|
+ return ()
|
|
|
+ origin = typing.get_origin(annotation)
|
|
|
+ if origin in (typing.Union, types.UnionType):
|
|
|
+ return tuple(a for a in typing.get_args(annotation) if a is not type(None))
|
|
|
+ return (annotation,)
|
|
|
+
|
|
|
+
|
|
|
+def _convert(value, annotation):
|
|
|
+ for kind in _base_types(annotation):
|
|
|
+ if kind is bool:
|
|
|
+ return str(value).lower() in ("1", "true", "yes", "on")
|
|
|
+ if kind is int:
|
|
|
+ return int(value)
|
|
|
+ if kind is float:
|
|
|
+ return float(value)
|
|
|
+ if kind is str:
|
|
|
+ return str(value)
|
|
|
+ return value
|
|
|
+
|
|
|
+
|
|
|
+def _model_type(annotation):
|
|
|
+ for kind in _base_types(annotation):
|
|
|
+ if inspect.isclass(kind) and hasattr(kind, "model_validate"):
|
|
|
+ return kind
|
|
|
+ return None
|
|
|
+
|
|
|
+
|
|
|
+def _arguments(fn, path_args, query, body):
|
|
|
+ kwargs = {}
|
|
|
+ for name, param in inspect.signature(fn).parameters.items():
|
|
|
+ annotation = param.annotation
|
|
|
+ if name in path_args:
|
|
|
+ kwargs[name] = _convert(path_args[name], annotation)
|
|
|
+ elif name == "request" or getattr(annotation, "__name__", "") == "Request":
|
|
|
+ kwargs[name] = _Request(query, body)
|
|
|
+ elif _model_type(annotation) is not None:
|
|
|
+ kwargs[name] = _model_type(annotation).model_validate(body or {})
|
|
|
+ elif name in query:
|
|
|
+ kwargs[name] = _convert(query[name], annotation)
|
|
|
+ elif name in ("body", "payload", "data") and body is not None:
|
|
|
+ kwargs[name] = body
|
|
|
+ elif param.default is not inspect.Parameter.empty:
|
|
|
+ kwargs[name] = param.default
|
|
|
+ return kwargs
|
|
|
+
|
|
|
+
|
|
|
+def _response(result):
|
|
|
+ if hasattr(result, "status_code") and hasattr(result, "body") and not hasattr(result, "kwargs"):
|
|
|
+ # Real starlette responses (JSONResponse, Response, PlainTextResponse).
|
|
|
+ raw = bytes(result.body or b"")
|
|
|
+ media = getattr(result, "media_type", None) or ""
|
|
|
+ if "json" in media:
|
|
|
+ import json
|
|
|
+ return {"status": int(result.status_code), "json": json.loads(raw or b"null")}
|
|
|
+ return {"status": int(result.status_code), "text": raw.decode("utf-8", "replace"), "media_type": media}
|
|
|
+ if hasattr(result, "path") and type(result).__name__ == "FileResponse" and not hasattr(result, "kwargs"):
|
|
|
+ return {"status": int(getattr(result, "status_code", 200)), "file": str(result.path),
|
|
|
+ "filename": getattr(result, "filename", None), "media_type": getattr(result, "media_type", None), "headers": {}}
|
|
|
+ args = getattr(result, "args", None)
|
|
|
+ options = getattr(result, "kwargs", None)
|
|
|
+ if args is None or options is None:
|
|
|
+ return {"status": 200, "json": result}
|
|
|
+ kind = type(result).__name__
|
|
|
+ if kind == "FileResponse":
|
|
|
+ path = options.get("path", args[0] if args else None)
|
|
|
+ return {"status": 200, "file": str(path), "filename": options.get("filename"),
|
|
|
+ "media_type": options.get("media_type"), "headers": options.get("headers") or {}}
|
|
|
+ status = int(options.get("status_code") or 200)
|
|
|
+ if kind == "JSONResponse":
|
|
|
+ return {"status": status, "json": options.get("content", args[0] if args else None)}
|
|
|
+ content = options.get("content", args[0] if args else b"")
|
|
|
+ if isinstance(content, bytes):
|
|
|
+ content = content.decode("utf-8", "replace")
|
|
|
+ return {"status": status, "text": content, "media_type": options.get("media_type")}
|
|
|
+
|
|
|
+
|
|
|
+def call(routes, error_type, args):
|
|
|
+ _load(routes)
|
|
|
+ method = str(args.get("method") or "GET").upper()
|
|
|
+ path = str(args.get("path") or "")
|
|
|
+ query = {k: v for k, v in (args.get("query") or {}).items() if k != "profile"}
|
|
|
+ body = args.get("body")
|
|
|
+ allowed = False
|
|
|
+ for route_method, pattern, _names, fn in _compiled:
|
|
|
+ match = pattern.match(path)
|
|
|
+ if not match:
|
|
|
+ continue
|
|
|
+ allowed = True
|
|
|
+ if route_method != method:
|
|
|
+ continue
|
|
|
+ try:
|
|
|
+ result = fn(**_arguments(fn, match.groupdict(), query, body))
|
|
|
+ if inspect.isawaitable(result):
|
|
|
+ result = asyncio.run(result) if inspect.iscoroutine(result) else asyncio.run(_await(result))
|
|
|
+ return _response(result)
|
|
|
+ except error_type as exc:
|
|
|
+ detail = getattr(exc, "detail", "") or str(exc)
|
|
|
+ return {"status": int(getattr(exc, "status_code", 500) or 500), "json": {"detail": detail}}
|
|
|
+ return {"status": 405 if allowed else 404, "json": {"detail": "Not Found" if not allowed else "Method Not Allowed"}}
|
|
|
+
|
|
|
+
|
|
|
+async def _await(value):
|
|
|
+ return await value
|