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/")
)