Newer
Older
gnexus-book / server / app / auth / middleware.py
from __future__ import annotations

from typing import Callable

from starlette.concurrency import run_in_threadpool
from starlette.requests import Request
from starlette.responses import JSONResponse
from starlette.types import ASGIApp, Receive, Scope, Send

from ..config import Settings
from ..storage.db import Database
from .actor import Actor, actor_for_current_user
from .context import current_actor, current_mcp_scopes
from .mcp_keys import resolve_mcp_token
from .sessions import CurrentUser, resolve_session


class SessionAuthMiddleware:
    """Resolve the browser session and guard non-exempt routes.

    Authentication is disabled when the gnexus-auth client is not configured, so
    local development and the file backend keep working without credentials.
    """

    def __init__(
        self, app: ASGIApp, settings_provider: Callable[[], Settings]
    ) -> None:
        self.app = app
        self._settings_provider = settings_provider
        self._database: Database | None = None

    def _db(self, settings: Settings) -> Database:
        if self._database is None:
            self._database = Database.from_settings(settings)
        return self._database

    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
        if scope["type"] != "http":
            await self.app(scope, receive, send)
            return

        settings = self._settings_provider()
        if not settings.auth_enabled:
            await self.app(scope, receive, send)
            return

        request = Request(scope)
        state = scope.setdefault("state", {})
        token = request.cookies.get(settings.auth_session_cookie)
        user: CurrentUser | None = None
        actor = None
        mcp_scopes: tuple[str, ...] | None = None

        if token:
            try:
                user = await run_in_threadpool(resolve_session, self._db(settings), token)
            except Exception:
                response = JSONResponse(
                    {"detail": "Authentication storage is unavailable"},
                    status_code=503,
                )
                await response(scope, receive, send)
                return
            if user is not None:
                actor = actor_for_current_user(user, via="ui")

        if user is None:
            authorization = request.headers.get("authorization", "")
            parts = authorization.split(None, 1)
            if len(parts) == 2 and parts[0].lower() == "bearer":
                try:
                    resolved = await run_in_threadpool(
                        resolve_mcp_token, self._db(settings), parts[1].strip()
                    )
                except Exception:
                    response = JSONResponse(
                        {"detail": "Authentication storage is unavailable"},
                        status_code=503,
                    )
                    await response(scope, receive, send)
                    return
                if resolved is not None:
                    user, key = resolved
                    mcp_scopes = tuple(key.scopes or [])
                    actor_kind = (
                        "user"
                        if request.headers.get("x-actor", "").lower() == "user"
                        else "agent"
                    )
                    actor = Actor(
                        kind=actor_kind,
                        name=key.name,
                        via="api",
                        user_id=user.id,
                    )

        state["user"] = user
        state["mcp_scopes"] = mcp_scopes
        actor_token = current_actor.set(actor or actor_for_current_user(None, via="ui"))
        scopes_token = current_mcp_scopes.set(mcp_scopes)
        try:
            if user is None and not _is_exempt(request.url.path):
                response = JSONResponse({"detail": "Not authenticated"}, status_code=401)
                await response(scope, receive, send)
                return
            await self.app(scope, receive, send)
        finally:
            current_actor.reset(actor_token)
            current_mcp_scopes.reset(scopes_token)


def _is_exempt(path: str) -> bool:
    return (
        path == "/health"
        or path == "/me"
        or path.startswith("/auth/")
        or path.startswith("/webhooks/gnexus-auth")
        or path.startswith("/internal/")
    )