myst/web/app/routers/setup.py
ZTatman 8e56a5bb1c feat(web): setup wizard, settings page, and Myst → Firebreak rename
Replace manual .env configuration with a browser-based setup wizard.
New users deploy with `docker compose up` and configure Forgejo OAuth
credentials through /setup on first visit. Existing users can
reconfigure via the same page (auth-gated post-setup).

Key changes:

Rename (Myst → Firebreak):
- Config fields, env vars, session cookie, templates, docker-compose,
  README all renamed from Myst to Firebreak

Setup wizard (/setup):
- New AppSettings single-row DB table stores Forgejo config
- Auto-generates Fernet encryption key on first setup
- SetupRequiredMiddleware redirects all routes to /setup pre-config
- Reconfigure mode pre-fills existing values, requires auth
- Landing page links to /setup for recovery if OAuth breaks

Settings page (/settings):
- PAT registration moved out of dashboard into dedicated page
- Token card with registration date, delete, and update actions
- Dashboard shows CTA linking to settings when no PAT registered

Auth updates:
- Routes use AppSettings from DB instead of env-based Settings
- OAuth callback redirects new users to /settings for PAT setup
- Forgejo API errors no longer leak upstream response bodies
- Decrypt failures return actionable 503 instead of unhandled 500

Code quality:
- Extracted templating.py to eliminate circular import hacks
- AppSettings.get_fernet() caches Fernet cipher instance
- User.has_pat property replaces scattered None checks
- lookup_session promoted to public API
- Dead code removed, return type annotations added
- PAT input fields use type="password"
- CSRF gap documented in agents.md for future addressing

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-06-03 11:15:44 -04:00

117 lines
4.6 KiB
Python

from __future__ import annotations
from typing import Annotated
from cryptography.fernet import Fernet
from fastapi import APIRouter, Cookie, Depends, Form, HTTPException, Request, status
from fastapi.responses import HTMLResponse, RedirectResponse
from pydantic import SecretStr
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from app.auth.crypto import encrypt_token, fernet_from_encryption_key
from app.auth.session import lookup_session
from app.deps import get_db
from app.models.app_settings import AppSettings
from app.templating import templates
router = APIRouter(prefix="/setup", tags=["setup"])
async def _require_auth_if_configured(
request: Request,
db: Annotated[AsyncSession, Depends(get_db)],
firebreak_session: Annotated[str | None, Cookie()] = None,
) -> None:
"""Block anonymous access to /setup after initial configuration."""
if not request.app.state.setup_complete:
return
sess = await lookup_session(db, firebreak_session)
if sess is None:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Sign in to reconfigure Firebreak.",
)
@router.get("", dependencies=[Depends(_require_auth_if_configured)], response_class=HTMLResponse)
async def setup_page(request: Request) -> HTMLResponse:
"""Render the setup wizard. Pre-fills fields when reconfiguring."""
existing = request.app.state.app_settings
ctx = {
"reconfiguring": existing is not None,
"forgejo_base_url": existing.forgejo_base_url if existing else "",
"forgejo_oauth_client_id": existing.forgejo_oauth_client_id if existing else "",
"firebreak_public_base_url": existing.firebreak_public_base_url if existing else "",
}
return templates.TemplateResponse(request, "setup.html", ctx)
@router.post("", dependencies=[Depends(_require_auth_if_configured)])
async def setup_submit(
request: Request,
db: Annotated[AsyncSession, Depends(get_db)],
forgejo_base_url: Annotated[str, Form()],
forgejo_oauth_client_id: Annotated[str, Form()],
forgejo_oauth_client_secret: Annotated[str, Form()] = "",
firebreak_public_base_url: Annotated[str, Form()] = "",
) -> RedirectResponse:
"""Process the setup wizard — creates or updates Forgejo settings."""
is_reconfiguring = request.app.state.setup_complete
forgejo_base_url = forgejo_base_url.strip().rstrip("/")
forgejo_oauth_client_id = forgejo_oauth_client_id.strip()
forgejo_oauth_client_secret = forgejo_oauth_client_secret.strip()
firebreak_public_base_url = firebreak_public_base_url.strip().rstrip("/")
if not forgejo_base_url or not forgejo_oauth_client_id:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Forgejo URL and Client ID are required.",
)
if is_reconfiguring:
result = await db.execute(select(AppSettings).where(AppSettings.id == 1))
row = result.scalar_one_or_none()
if row is None:
raise HTTPException(
status_code=500, detail="Settings row missing during reconfiguration."
)
row.forgejo_base_url = forgejo_base_url
row.forgejo_oauth_client_id = forgejo_oauth_client_id
row.firebreak_public_base_url = firebreak_public_base_url
if forgejo_oauth_client_secret:
row.forgejo_oauth_client_secret_encrypted = encrypt_token(
row.get_fernet(), forgejo_oauth_client_secret
)
await db.commit()
await db.refresh(row)
request.app.state.app_settings = row
return RedirectResponse("/", status_code=status.HTTP_303_SEE_OTHER)
# First-time setup — no auth required (no users exist yet)
if not forgejo_oauth_client_secret:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Client Secret is required during initial setup.",
)
encryption_key = Fernet.generate_key().decode()
fernet = fernet_from_encryption_key(SecretStr(encryption_key))
encrypted_secret = encrypt_token(fernet, forgejo_oauth_client_secret)
row = AppSettings(
id=1,
forgejo_base_url=forgejo_base_url,
forgejo_oauth_client_id=forgejo_oauth_client_id,
forgejo_oauth_client_secret_encrypted=encrypted_secret,
firebreak_public_base_url=firebreak_public_base_url,
token_encryption_key=encryption_key,
)
db.add(row)
await db.commit()
await db.refresh(row)
request.app.state.setup_complete = True
request.app.state.app_settings = row
return RedirectResponse("/", status_code=status.HTTP_303_SEE_OTHER)