minder-cli 0.2.0__py3-none-any.whl

minder/presentation/http/admin/context.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable
+
+from minder.application.admin.use_cases import AdminConsoleUseCases
+from minder.auth.principal import ClientPrincipal, Principal
+from minder.auth.middleware import AuthMiddleware
+from minder.auth.service import AuthService
+from minder.config import MinderConfig
+from minder.store.interfaces import ICacheProvider, IGraphRepository, IOperationalStore
+from starlette.requests import Request
+
+ADMIN_COOKIE_NAME = "minder_admin_token"
+
+
+@dataclass(slots=True)
+class AdminRouteContext:
+    config: MinderConfig
+    store: IOperationalStore
+    graph_store: IGraphRepository | None
+    cache: ICacheProvider | None
+    auth_service: AuthService
+    middleware: AuthMiddleware
+    use_cases: AdminConsoleUseCases
+    prompt_sync_hook: Callable[[], Awaitable[None]] | None = None
+
+    @classmethod
+    def build(
+        cls,
+        *,
+        config: MinderConfig,
+        store: IOperationalStore,
+        graph_store: IGraphRepository | None = None,
+        cache: ICacheProvider | None = None,
+        prompt_sync_hook: Callable[[], Awaitable[None]] | None = None,
+    ) -> "AdminRouteContext":
+        auth_service = AuthService(store, config, cache=cache)
+        middleware = AuthMiddleware(auth_service)
+        use_cases = AdminConsoleUseCases(
+            store=store,
+            auth_service=auth_service,
+            config=config,
+            graph_store=graph_store,
+        )
+        return cls(
+            config=config,
+            store=store,
+            graph_store=graph_store,
+            cache=cache,
+            auth_service=auth_service,
+            middleware=middleware,
+            use_cases=use_cases,
+            prompt_sync_hook=prompt_sync_hook,
+        )
+
+    def request_token(self, request: Request) -> str | None:
+        authorization = request.headers.get("Authorization")
+        if authorization:
+            return authorization
+        cookie_token = request.cookies.get(ADMIN_COOKIE_NAME)
+        if cookie_token:
+            return f"Bearer {cookie_token}"
+        return None
+
+    @staticmethod
+    def request_client_key(request: Request) -> str | None:
+        client_key = request.headers.get("X-Minder-Client-Key")
+        if client_key and client_key.strip():
+            return client_key.strip()
+        return None
+
+    async def principal_from_request(
+        self,
+        request: Request,
+        *,
+        requested_scopes: list[str] | None = None,
+    ) -> Principal:
+        return await self.middleware.authenticate_principal(
+            self.request_token(request),
+            client_key=self.request_client_key(request),
+        )
+
+    async def client_principal_from_request(self, request: Request) -> ClientPrincipal:
+        principal = await self.principal_from_request(request)
+        if not isinstance(principal, ClientPrincipal):
+            raise PermissionError("Client principal required")
+        return principal
+
+    async def admin_user_from_request(self, request: Request) -> Any:
+        user = await self.middleware.authenticate(self.request_token(request))
+        if user.role != "admin":
+            raise PermissionError("Admin role required")
+        return user

minder/presentation/http/admin/dashboard.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from starlette.responses import FileResponse, PlainTextResponse, RedirectResponse
+from starlette.routing import BaseRoute, Route
+
+from .context import AdminRouteContext
+
+
+def _resolve_dashboard_static_root(static_dir: Path) -> Path:
+    if (static_dir / "index.html").is_file():
+        return static_dir
+
+    client_dir = static_dir / "client"
+    if client_dir.is_dir() and (client_dir / "index.html").is_file():
+        return client_dir
+
+    return static_dir
+
+
+def build_dashboard_routes(context: AdminRouteContext) -> list[BaseRoute]:
+    def _dev_dashboard_url(asset_path: str = "") -> str | None:
+        dev_server_url = (context.config.dashboard.dev_server_url or "").strip().rstrip("/")
+        if not dev_server_url:
+            return None
+        if asset_path:
+            return f"{dev_server_url}/{asset_path.strip('/')}"
+        return dev_server_url
+
+    async def dashboard_static(request):
+        asset_path = str(request.path_params.get("asset_path", "")).strip("/")
+        dev_target = _dev_dashboard_url(asset_path)
+        if dev_target is not None:
+            return RedirectResponse(url=dev_target, status_code=307)
+
+        static_dir = Path(context.config.dashboard.static_dir).expanduser()
+
+        async def _has_admin_session() -> bool:
+            try:
+                await context.admin_user_from_request(request)
+            except Exception:
+                return False
+            return True
+
+        has_admin_users = await context.use_cases.has_admin_users()
+        has_admin_session = await _has_admin_session()
+        is_asset_request = "." in Path(asset_path).name or asset_path.startswith("_astro/")
+
+        if not is_asset_request:
+            if not has_admin_users and asset_path not in {"setup"}:
+                return RedirectResponse(url=f"{context.config.dashboard.base_path}/setup", status_code=303)
+            if has_admin_users and asset_path == "setup":
+                target = (
+                    f"{context.config.dashboard.base_path}/clients"
+                    if has_admin_session
+                    else f"{context.config.dashboard.base_path}/login"
+                )
+                return RedirectResponse(url=target, status_code=303)
+            if has_admin_users and not has_admin_session and asset_path not in {"login"}:
+                return RedirectResponse(url=f"{context.config.dashboard.base_path}/login", status_code=303)
+            if has_admin_users and has_admin_session and asset_path in {"", "login"}:
+                return RedirectResponse(url=f"{context.config.dashboard.base_path}/clients", status_code=303)
+
+        if not static_dir.exists():
+            return PlainTextResponse("Dashboard build not found", status_code=404)
+
+        static_root = _resolve_dashboard_static_root(static_dir)
+
+        if not asset_path:
+            candidates = [static_root / "index.html"]
+        else:
+            requested = static_root / asset_path
+            candidates = [requested, requested / "index.html"]
+
+        for candidate in candidates:
+            if candidate.exists() and candidate.is_file():
+                return FileResponse(candidate)
+
+        if asset_path.startswith("clients/"):
+            detail_shell = static_root / "clients" / "_client-detail" / "index.html"
+            if detail_shell.exists() and detail_shell.is_file():
+                return FileResponse(detail_shell)
+
+            clients_index = static_root / "clients" / "index.html"
+            if clients_index.exists() and clients_index.is_file():
+                return FileResponse(clients_index)
+
+        fallback = static_root / "index.html"
+        if fallback.exists() and fallback.is_file():
+            return FileResponse(fallback)
+        return PlainTextResponse("Dashboard build not found", status_code=404)
+
+    async def setup_redirect(_):
+        dev_target = _dev_dashboard_url("setup")
+        if dev_target is not None:
+            return RedirectResponse(url=dev_target, status_code=308)
+        return RedirectResponse(url=f"{context.config.dashboard.base_path}/setup", status_code=308)
+
+    async def dashboard_favicon_ico(_):
+        dev_target = _dev_dashboard_url("favicon.png")
+        if dev_target is not None:
+            return RedirectResponse(url=dev_target, status_code=308)
+        return RedirectResponse(url=f"{context.config.dashboard.base_path}/favicon.png", status_code=308)
+
+    return [
+        Route("/setup", setup_redirect, methods=["GET"]),
+        Route(f"{context.config.dashboard.base_path}/favicon.ico", dashboard_favicon_ico, methods=["GET"]),
+        Route(f"{context.config.dashboard.base_path}", dashboard_static, methods=["GET"]),
+        Route(f"{context.config.dashboard.base_path}" + "/{asset_path:path}", dashboard_static, methods=["GET"]),
+    ]

minder/presentation/http/admin/jobs.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+import json
+import logging
+import uuid
+from typing import Any
+
+from pydantic import BaseModel, Field
+from starlette.requests import Request
+from starlette.responses import JSONResponse, StreamingResponse
+from starlette.routing import BaseRoute, Route
+
+from minder.application.admin.jobs import AdminJobService, iter_job_stream
+
+from .context import AdminRouteContext
+
+logger = logging.getLogger(__name__)
+
+
+class AdminJobCreateRequest(BaseModel):
+    job_type: str
+    payload: dict[str, Any] = Field(default_factory=dict)
+
+
+def _job_service_from_request(
+    request: Request,
+    context: AdminRouteContext,
+) -> AdminJobService:
+    service = getattr(request.app.state, "job_service", None)
+    if isinstance(service, AdminJobService):
+        return service
+    service = AdminJobService(context.store, context.config)
+    request.app.state.job_service = service
+    return service
+
+
+def _serialize_job(job: Any) -> dict[str, Any]:
+    created_at = getattr(job, "created_at", None)
+    updated_at = getattr(job, "updated_at", None)
+    started_at = getattr(job, "started_at", None)
+    finished_at = getattr(job, "finished_at", None)
+    progress_current = int(getattr(job, "progress_current", 0) or 0)
+    progress_total = int(getattr(job, "progress_total", 0) or 0)
+    progress_percent = 0.0
+    if progress_total > 0:
+        progress_percent = round((progress_current / progress_total) * 100, 1)
+    return {
+        "id": str(job.id),
+        "job_type": str(getattr(job, "job_type", "")),
+        "title": str(getattr(job, "title", "")),
+        "status": str(getattr(job, "status", "queued")),
+        "requested_by_user_id": (
+            str(getattr(job, "requested_by_user_id", ""))
+            if getattr(job, "requested_by_user_id", None)
+            else None
+        ),
+        "payload": dict(getattr(job, "payload", {}) or {}),
+        "result_payload": getattr(job, "result_payload", None),
+        "error_message": getattr(job, "error_message", None),
+        "progress_current": progress_current,
+        "progress_total": progress_total,
+        "progress_percent": progress_percent,
+        "message": getattr(job, "message", None),
+        "events": list(getattr(job, "events", []) or []),
+        "created_at": created_at.isoformat() if created_at else None,
+        "updated_at": updated_at.isoformat() if updated_at else None,
+        "started_at": started_at.isoformat() if started_at else None,
+        "finished_at": finished_at.isoformat() if finished_at else None,
+    }
+
+
+def _job_title(job_type: str, payload: dict[str, Any]) -> str:
+    if job_type == "skill_import_git":
+        repo_url = str(payload.get("repo_url") or "").strip()
+        return f"Import skills from {repo_url or 'Git repository'}"
+    return job_type.replace("_", " ").strip() or "Admin job"
+
+
+def build_jobs_routes(context: AdminRouteContext) -> list[BaseRoute]:
+    async def create_job(request: Request) -> JSONResponse:
+        try:
+            admin_user = await context.admin_user_from_request(request)
+        except PermissionError:
+            return JSONResponse({"error": "Admin role required"}, status_code=403)
+        except Exception as exc:
+            return JSONResponse({"error": str(exc)}, status_code=401)
+
+        try:
+            payload = AdminJobCreateRequest(**(await request.json()))
+            if payload.job_type != "skill_import_git":
+                return JSONResponse(
+                    {"error": f"Unsupported job type: {payload.job_type}"},
+                    status_code=400,
+                )
+            service = _job_service_from_request(request, context)
+            job = await service.enqueue(
+                job_type=payload.job_type,
+                title=_job_title(payload.job_type, payload.payload),
+                requested_by_user_id=admin_user.id,
+                payload=payload.payload,
+            )
+            return JSONResponse(_serialize_job(job), status_code=202)
+        except Exception as exc:
+            logger.exception("Failed to create admin job", exc_info=exc)
+            return JSONResponse({"error": str(exc)}, status_code=400)
+
+    async def list_jobs(request: Request) -> JSONResponse:
+        try:
+            await context.admin_user_from_request(request)
+        except PermissionError:
+            return JSONResponse({"error": "Admin role required"}, status_code=403)
+        except Exception as exc:
+            return JSONResponse({"error": str(exc)}, status_code=401)
+
+        job_type = (request.query_params.get("job_type") or "").strip() or None
+        status = (request.query_params.get("status") or "").strip() or None
+        limit = int(request.query_params.get("limit") or 50)
+        jobs = await context.store.list_admin_jobs(
+            job_type=job_type,
+            status=status,
+            limit=limit,
+        )
+        return JSONResponse(
+            {"jobs": [_serialize_job(job) for job in jobs], "limit": limit}
+        )
+
+    async def get_job(request: Request) -> JSONResponse:
+        try:
+            await context.admin_user_from_request(request)
+        except PermissionError:
+            return JSONResponse({"error": "Admin role required"}, status_code=403)
+        except Exception as exc:
+            return JSONResponse({"error": str(exc)}, status_code=401)
+
+        job_id = uuid.UUID(str(request.path_params["job_id"]))
+        job = await context.store.get_admin_job_by_id(job_id)
+        if job is None:
+            return JSONResponse({"error": "Job not found"}, status_code=404)
+        return JSONResponse(_serialize_job(job))
+
+    async def stream_jobs(request: Request) -> StreamingResponse | JSONResponse:
+        try:
+            await context.admin_user_from_request(request)
+        except PermissionError:
+            return JSONResponse({"error": "Admin role required"}, status_code=403)
+        except Exception as exc:
+            return JSONResponse({"error": str(exc)}, status_code=401)
+
+        job_type = (request.query_params.get("job_type") or "").strip() or None
+        status_values = {
+            value.strip()
+            for value in (request.query_params.get("status") or "").split(",")
+            if value.strip()
+        }
+        service = _job_service_from_request(request, context)
+        queue, unsubscribe = service.subscribe(
+            job_type=job_type,
+            statuses=status_values or None,
+        )
+
+        async def event_stream():
+            try:
+                async for event in iter_job_stream(
+                    queue=queue,
+                    request_is_disconnected=request.is_disconnected,
+                ):
+                    yield f"data: {json.dumps(event)}\n\n"
+            finally:
+                unsubscribe()
+
+        return StreamingResponse(event_stream(), media_type="text/event-stream")
+
+    async def stream_job(request: Request) -> StreamingResponse | JSONResponse:
+        try:
+            await context.admin_user_from_request(request)
+        except PermissionError:
+            return JSONResponse({"error": "Admin role required"}, status_code=403)
+        except Exception as exc:
+            return JSONResponse({"error": str(exc)}, status_code=401)
+
+        job_id = uuid.UUID(str(request.path_params["job_id"]))
+        existing = await context.store.get_admin_job_by_id(job_id)
+        if existing is None:
+            return JSONResponse({"error": "Job not found"}, status_code=404)
+
+        service = _job_service_from_request(request, context)
+        queue, unsubscribe = service.subscribe(job_id=str(job_id))
+
+        async def event_stream():
+            try:
+                yield f"data: {json.dumps({'type': 'job', 'payload': _serialize_job(existing)})}\n\n"
+                async for event in iter_job_stream(
+                    queue=queue,
+                    request_is_disconnected=request.is_disconnected,
+                ):
+                    yield f"data: {json.dumps(event)}\n\n"
+            finally:
+                unsubscribe()
+
+        return StreamingResponse(event_stream(), media_type="text/event-stream")
+
+    return [
+        Route("/api/v1/jobs", list_jobs, methods=["GET"]),
+        Route("/api/v1/jobs", create_job, methods=["POST"]),
+        Route("/api/v1/jobs/stream", stream_jobs, methods=["GET"]),
+        Route("/api/v1/jobs/{job_id}", get_job, methods=["GET"]),
+        Route("/api/v1/jobs/{job_id}/stream", stream_job, methods=["GET"]),
+    ]

minder/presentation/http/admin/memories.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import logging
+import uuid
+from typing import Any
+
+from pydantic import BaseModel, Field
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+from starlette.routing import BaseRoute, Route
+
+from minder.config import MinderConfig
+from minder.embedding.local import LocalEmbeddingProvider
+from minder.observability.metrics import record_admin_operation
+from minder.tools.memory import MemoryTools
+
+from .context import AdminRouteContext
+
+logger = logging.getLogger(__name__)
+
+
+class MemoryCreateRequest(BaseModel):
+    title: str
+    content: str
+    language: str = "markdown"
+    tags: list[str] = Field(default_factory=list)
+
+
+class MemoryUpdateRequest(BaseModel):
+    title: str | None = None
+    content: str | None = None
+    language: str | None = None
+    tags: list[str] | None = None
+
+
+def _config_from_request(request: Request) -> MinderConfig:
+    config = getattr(request.app.state, "config", None)
+    if isinstance(config, MinderConfig):
+        return config
+    return MinderConfig()
+
+
+def _serialize_memory(skill: Any) -> dict[str, Any]:
+    return {
+        "id": str(skill.id),
+        "title": str(skill.title),
+        "content": str(skill.content),
+        "language": str(getattr(skill, "language", "markdown") or "markdown"),
+        "tags": list(getattr(skill, "tags", []) or []),
+        "created_at": skill.created_at.isoformat() if skill.created_at else None,
+        "updated_at": skill.updated_at.isoformat() if skill.updated_at else None,
+    }
+
+
+def build_memories_routes(context: AdminRouteContext) -> list[BaseRoute]:
+    async def list_memories(request: Request) -> JSONResponse:
+        del request
+        await record_admin_operation(
+            operation="list_memories",
+            outcome="success",
+            actor_id="system",
+            store=context.store,
+        )
+        try:
+            skills = sorted(
+                await context.store.list_skills(),
+                key=lambda skill: (
+                    str(getattr(skill, "title", "")).lower(),
+                    str(getattr(skill, "language", "")).lower(),
+                ),
+            )
+            return JSONResponse([_serialize_memory(skill) for skill in skills])
+        except Exception as exc:
+            logger.exception("Failed to list memories", exc_info=exc)
+            return JSONResponse({"error": str(exc)}, status_code=500)
+
+    async def get_memory(request: Request) -> JSONResponse:
+        memory_id = request.path_params["memory_id"]
+        await record_admin_operation(
+            operation="get_memory",
+            outcome="success",
+            actor_id="system",
+            store=context.store,
+        )
+        try:
+            skill = await context.store.get_skill_by_id(uuid.UUID(memory_id))
+            if skill is None:
+                return JSONResponse({"error": "Memory not found"}, status_code=404)
+            return JSONResponse(_serialize_memory(skill))
+        except Exception as exc:
+            logger.exception("Failed to get memory", exc_info=exc)
+            return JSONResponse({"error": str(exc)}, status_code=500)
+
+    async def create_memory(request: Request) -> JSONResponse:
+        await record_admin_operation(
+            operation="create_memory",
+            outcome="success",
+            actor_id="system",
+            store=context.store,
+        )
+        try:
+            payload = MemoryCreateRequest(**(await request.json()))
+            tools = MemoryTools(context.store, _config_from_request(request))
+            created = await tools.minder_memory_store(
+                title=payload.title,
+                content=payload.content,
+                tags=payload.tags,
+                language=payload.language,
+            )
+            skill = await context.store.get_skill_by_id(uuid.UUID(created["id"]))
+            if skill is None:
+                return JSONResponse(created, status_code=201)
+            return JSONResponse(_serialize_memory(skill), status_code=201)
+        except Exception as exc:
+            logger.exception("Failed to create memory", exc_info=exc)
+            return JSONResponse({"error": str(exc)}, status_code=400)
+
+    async def update_memory(request: Request) -> JSONResponse:
+        memory_id = request.path_params["memory_id"]
+        await record_admin_operation(
+            operation="update_memory",
+            outcome="success",
+            actor_id="system",
+            store=context.store,
+        )
+        try:
+            payload = MemoryUpdateRequest(**(await request.json()))
+            existing = await context.store.get_skill_by_id(uuid.UUID(memory_id))
+            if existing is None:
+                return JSONResponse({"error": "Memory not found"}, status_code=404)
+
+            update_data = payload.model_dump(exclude_unset=True)
+            next_title = str(update_data.get("title") or existing.title)
+            next_content = str(update_data.get("content") or existing.content)
+            if "tags" in update_data and update_data["tags"] is not None:
+                update_data["tags"] = [
+                    str(tag).strip() for tag in update_data["tags"] if str(tag).strip()
+                ]
+
+            if "title" in update_data or "content" in update_data:
+                config = _config_from_request(request)
+                embedder = LocalEmbeddingProvider(
+                    config.embedding.model_path,
+                    dimensions=min(config.embedding.dimensions, 16),
+                    runtime="auto",
+                )
+                update_data["embedding"] = embedder.embed(
+                    f"{next_title}\n{next_content}"
+                )
+
+            updated = await context.store.update_skill(
+                uuid.UUID(memory_id), **update_data
+            )
+            if updated is None:
+                return JSONResponse({"error": "Memory not found"}, status_code=404)
+            return JSONResponse(_serialize_memory(updated))
+        except Exception as exc:
+            logger.exception("Failed to update memory", exc_info=exc)
+            return JSONResponse({"error": str(exc)}, status_code=400)
+
+    async def delete_memory(request: Request) -> JSONResponse:
+        memory_id = request.path_params["memory_id"]
+        await record_admin_operation(
+            operation="delete_memory",
+            outcome="success",
+            actor_id="system",
+            store=context.store,
+        )
+        try:
+            skill = await context.store.get_skill_by_id(uuid.UUID(memory_id))
+            if skill is None:
+                return JSONResponse({"error": "Memory not found"}, status_code=404)
+            await context.store.delete_skill(uuid.UUID(memory_id))
+            return JSONResponse({"deleted": True}, status_code=200)
+        except Exception as exc:
+            logger.exception("Failed to delete memory", exc_info=exc)
+            return JSONResponse({"error": str(exc)}, status_code=500)
+
+    return [
+        Route("/api/v1/memories", list_memories, methods=["GET"]),
+        Route("/api/v1/memories", create_memory, methods=["POST"]),
+        Route("/api/v1/memories/{memory_id}", get_memory, methods=["GET"]),
+        Route("/api/v1/memories/{memory_id}", update_memory, methods=["PATCH", "PUT"]),
+        Route("/api/v1/memories/{memory_id}", delete_memory, methods=["DELETE"]),
+    ]