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>
This commit is contained in:
ZTatman 2026-06-03 11:15:44 -04:00
parent fda444b808
commit 8e56a5bb1c
22 changed files with 702 additions and 322 deletions

View file

@ -1,14 +1,14 @@
# Myst
# Firebreak
> My stuff, kept private.
> Fight fire with fire. Your code. Your rules.
Myst is a companion service for Forgejo that lets repo owners create expiring, revocable, read-only share links for code snapshots.
Firebreak is a companion service for Forgejo that lets repo owners create expiring, revocable, read-only share links for code snapshots.
## System Diagram
This diagram shows how traffic moves through the public internet, the VPS or self-hosted server, the host firewall, the platform router, Myst, Forgejo, and Postgres.
This diagram shows how traffic moves through the public internet, the VPS or self-hosted server, the host firewall, the platform router, Firebreak, Forgejo, and Postgres.
[![Myst system routing diagram](docs/diagrams/system-routing.svg)](docs/diagrams/system-routing.svg)
[![Firebreak system routing diagram](docs/diagrams/system-routing.svg)](docs/diagrams/system-routing.svg)
Click the diagram to open the full-size SVG.
@ -33,8 +33,8 @@ Click the diagram to open the full-size SVG.
| Purpose | Method |
|---------|--------|
| User Identity | Forgejo Sessions |
| Data Access | Dedicated Forgejo User PAT |
| User Identity | Forgejo OAuth |
| Data Access | User's Forgejo PAT |
### Tech Stack
@ -46,91 +46,50 @@ HTMX provides interactivity (filtering, form submissions) with minimal JavaScrip
## Quick Start
### 1. Run `myst config init`
### 1. Deploy with Docker Compose
```bash
myst config init
```
Prompts for:
- Forgejo API URL — Docker: `http://forgejo:3000`, bare metal: `http://localhost:3000`, cross-host: `https://git.example.com`
- Forgejo PAT (with `read:user` and `read:repository` scopes)
### 2. Deploy with Docker Compose
```bash
cp examples/.env.example .env
# Edit .env with your FORGEJO_BASE_URL and FORGEJO_PAT
docker compose up -d
```
The DATABASE_URL is injected automatically by Docker Compose.
### 2. Run the Setup Wizard
### 3. Alternative Deployments
Open `http://localhost:8000` in your browser. On first boot, Firebreak redirects to a setup wizard where you configure:
For non-Docker deployments, you must supply DATABASE_URL yourself:
- **Forgejo instance URL** — where your Forgejo server lives
- **OAuth credentials** — register an OAuth application in Forgejo first (Settings → Applications → Create OAuth2 Application), then paste the Client ID and Client Secret
- **Public base URL** (optional) — your production domain for OAuth redirects
- VPS deployment: Hostinger or another VPS with Dokploy, Traefik, UFW, Myst, Forgejo, and a shared Postgres instance that contains separate `forgejo` and `myst` databases.
- Self-hosted server deployment: a home server, mini PC, NAS, or other self-hosted Linux machine running Myst with Docker, Podman, Docker Compose, Coolify, Caddy, Nginx, or another reverse proxy.
The setup wizard auto-generates an encryption key for token storage.
Myst should not assume a VPS-only environment. The requirement is an existing Forgejo instance, Myst's own database, and a way to route the public and admin hostnames to the Myst app.
### 3. Sign In and Register Your Token
## Example Configuration
After setup, sign in with your Forgejo account via OAuth. On first login, Firebreak prompts you to register a `read:repository`-scoped Personal Access Token (PAT) to enable share link viewing.
Create a `.env` file with:
### 4. Alternative Deployments
```env
# Docker (same Compose network):
FORGEJO_BASE_URL=http://forgejo:3000
# Bare metal / non-container:
# FORGEJO_BASE_URL=http://localhost:3000
# Cross-host:
# FORGEJO_BASE_URL=https://git.example.com
FORGEJO_PAT=forgejo_pat_xxxxxxxxxxxx
```
For non-Docker deployments, supply `DATABASE_URL` yourself:
When using the provided Docker Compose example, DATABASE_URL is injected automatically. For other deployment approaches (e.g., bare metal, Kubernetes), you must supply DATABASE_URL yourself.
- VPS deployment: Hostinger or another VPS with Dokploy, Traefik, UFW, Firebreak, Forgejo, and a shared Postgres instance that contains separate `forgejo` and `firebreak` databases.
- Self-hosted server deployment: a home server, mini PC, NAS, or other self-hosted Linux machine running Firebreak with Docker, Podman, Docker Compose, Coolify, Caddy, Nginx, or another reverse proxy.
### 4. Register an OAuth application in Forgejo
The web service authenticates users via Forgejo OAuth. You need to register Myst as an OAuth consumer:
1. In Forgejo, go to **Settings** → **Applications** → **Create OAuth2 Application**
2. Set the redirect URI to `https://your-myst-domain.com/auth/callback/forgejo` (or `http://localhost:8000/auth/callback/forgejo` for local dev)
3. Copy the **Client ID** and **Client Secret** Forgejo gives you
4. Generate a Fernet encryption key for token storage:
```bash
python3 -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"
```
5. Add these to your `.env`:
```env
FORGEJO_OAUTH_CLIENT_ID=your_client_id
FORGEJO_OAUTH_CLIENT_SECRET=your_client_secret
TOKEN_ENCRYPTION_KEY=your_fernet_key_from_step_4
MYST_PUBLIC_BASE_URL=https://your-myst-domain.com # omit trailing slash; omit for local dev
```
`MYST_PUBLIC_BASE_URL` is used as the OAuth redirect URI base. In local development, the redirect URI is inferred from the request (Default: `http://localhost:8000/auth/callback/forgejo`). In production, set this to your public Myst domain.
Firebreak should not assume a VPS-only environment. The requirement is an existing Forgejo instance, Firebreak's own database, and a way to route the public and admin hostnames to the Firebreak app.
## Phase 1 Progress
- [x] Project renamed from Embargo to Myst
- [x] CLI scaffold (`myst config init`)
- [x] Project renamed from Embargo to Firebreak
- [x] CLI scaffold (`firebreak config init`)
- [x] Config generation (`.env`)
- [ ] Service foundation (FastAPI + PostgreSQL)
- [x] `myst config verify` — verify Forgejo connectivity
- [x] `myst config verify --diagnostic` — comprehensive diagnostics
- [x] `myst config view` — show current config
- [ ] Forgejo session authentication
- [x] `firebreak config verify` — verify Forgejo connectivity
- [x] `firebreak config verify --diagnostic` — comprehensive diagnostics
- [x] `firebreak config view` — show current config
- [x] Forgejo OAuth authentication
- [ ] Repo ownership verification
- [ ] Private link creation (email-verified)
- [ ] Public link creation (time-expired)
- [ ] Web-based code viewer
- [ ] User dashboard
- [x] User dashboard
- [ ] SMTP configuration UI
- [ ] Access logs

View file

@ -116,6 +116,12 @@ This file is the single source of truth for codebase obstacles, oddities, and th
**Solution/Workaround:** Use a real video-frame poster image (`firebreak-hero-poster.jpg`) or omit `poster`; do not use logo assets as full-bleed video posters.
**Preference:** Keep logo sizing in the logo `<img>` and use a frame still for video loading states.
### POST forms lack CSRF tokens
**Area:** web/app/routers/setup.py, web/app/routers/settings.py, web/app/templates/setup.html, web/app/templates/settings.html
**Obstacle:** All state-changing forms (`/setup`, `/settings/pat`, `/settings/pat/delete`) use plain POST with no CSRF token. SameSite=Lax on the session cookie mitigates most cross-origin attacks, but does not fully cover same-site subdomain scenarios.
**Solution/Workaround:** Deferred. Low practical risk since Firebreak runs behind a VPN. Add server-generated CSRF tokens (hidden form field + server-side check) before exposing the app to the public internet.
**Preference:** Use a FastAPI CSRF middleware or manual double-submit cookie pattern when addressing this.
### Firebreak UI is currently dark-only
**Area:** web/app/templates/base.html, web/app/static/css/input.css
**Obstacle:** Theme switching and persisted localStorage theme state conflicted with the current Firebreak brand pass, especially on the cinematic landing page.

View file

@ -7,7 +7,7 @@ services:
- "8000:8000"
env_file: ./web/.env
environment:
- DATABASE_URL=postgresql+asyncpg://myst:myst@db:5432/myst_db
- DATABASE_URL=postgresql+asyncpg://firebreak:firebreak@db:5432/firebreak_db
depends_on:
db:
condition: service_healthy
@ -17,13 +17,13 @@ services:
ports:
- "5432:5432"
environment:
POSTGRES_USER: myst
POSTGRES_PASSWORD: myst
POSTGRES_DB: myst_db
POSTGRES_USER: firebreak
POSTGRES_PASSWORD: firebreak
POSTGRES_DB: firebreak_db
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U myst -d myst_db"]
test: ["CMD-SHELL", "pg_isready -U firebreak -d firebreak_db"]
interval: 5s
timeout: 5s
retries: 5

View file

@ -6,14 +6,14 @@ from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.orm import selectinload
from app.auth.crypto import encrypt_optional, fernet_from_encryption_key
from app.config import Settings
from app.auth.crypto import encrypt_optional
from app.models.app_settings import AppSettings
from app.models.user import LinkedIdentity, User
async def find_or_create_user(
db: AsyncSession,
settings: Settings,
app_settings: AppSettings,
*,
provider: str,
provider_user_id: str,
@ -25,10 +25,8 @@ async def find_or_create_user(
) -> User:
"""Find or create a user based on the given provider and identity details."""
# Create a Fernet instance for encrypting tokens if a key is available
fernet = fernet_from_encryption_key(settings.token_encryption_key)
fernet = app_settings.get_fernet()
# Query the database for an existing identity
result = await db.execute(
select(LinkedIdentity)
.options(selectinload(LinkedIdentity.user))
@ -39,7 +37,6 @@ async def find_or_create_user(
)
identity = result.scalar_one_or_none()
# Update the identity and user if identity exists
if identity:
identity.provider_username = provider_username
if access_token_raw is not None:

View file

@ -14,7 +14,7 @@ from sqlalchemy.orm import selectinload
from app.deps import get_db
from app.models.session import Session
SESSION_COOKIE = "myst_session"
SESSION_COOKIE = "firebreak_session"
SESSION_DURATION_DAYS = 7
@ -48,19 +48,15 @@ async def create_session(
)
async def _lookup_session(
async def lookup_session(
db: AsyncSession,
myst_session: str | None,
firebreak_session: str | None,
) -> Session | None:
"""Return the active session for a raw cookie token, if one exists."""
# Missing cookie means anonymous request. Callers decide whether anonymous is
# acceptable with get_optional_session or should become a 401.
if not myst_session:
if not firebreak_session:
return None
# Match the incoming cookie by hashing it the same way create_session did.
# Only active, non-expired sessions are accepted.
token_hash = hashlib.sha256(myst_session.encode()).hexdigest()
token_hash = hashlib.sha256(firebreak_session.encode()).hexdigest()
now = datetime.now(UTC)
stmt = (
select(Session)
@ -85,12 +81,11 @@ async def _lookup_session(
async def get_current_session(
db: Annotated[AsyncSession, Depends(get_db)],
myst_session: Annotated[str | None, Cookie()] = None,
firebreak_session: Annotated[str | None, Cookie()] = None,
) -> Session:
"""FastAPI dependency that requires a valid signed-in session."""
# Use this dependency on routes that require a signed-in user.
sess = await _lookup_session(db, myst_session)
sess = await lookup_session(db, firebreak_session)
if sess is None:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
@ -101,37 +96,28 @@ async def get_current_session(
async def get_optional_session(
db: Annotated[AsyncSession, Depends(get_db)],
myst_session: Annotated[str | None, Cookie()] = None,
firebreak_session: Annotated[str | None, Cookie()] = None,
) -> Session | None:
"""FastAPI dependency that returns the current session when available. Used on pages that can render differently for anonymous and signed-in users."""
"""FastAPI dependency that returns the current session when available."""
return await _lookup_session(db, myst_session)
return await lookup_session(db, firebreak_session)
async def revoke_session(db: AsyncSession, response: Response, myst_session: str | None) -> None:
async def revoke_session(db: AsyncSession, response: Response, firebreak_session: str | None) -> None:
"""Delete the browser cookie and mark the matching session as revoked."""
# Always ask the browser to delete its cookie, even if the DB row is already
# missing or revoked.
response.delete_cookie(
key=SESSION_COOKIE,
path="/",
samesite="lax",
httponly=True,
)
if not myst_session:
if not firebreak_session:
return
# Revoke by hash for the same reason we store sessions by hash: the raw
# cookie token should only exist in the browser.
token_hash = hashlib.sha256(myst_session.encode()).hexdigest()
token_hash = hashlib.sha256(firebreak_session.encode()).hexdigest()
result = await db.execute(
update(Session)
.where(Session.token_hash == token_hash, Session.revoked_at.is_(None))
.values(revoked_at=datetime.now(UTC))
)
await db.commit()
# Bypasses the strict static type checking check safely
rowcount = getattr(result, "rowcount", 0)
if rowcount == 0:
pass

View file

@ -1,30 +1,37 @@
from __future__ import annotations
from functools import lru_cache
from pathlib import Path
from typing import ClassVar
from typing import TYPE_CHECKING
from pydantic import SecretStr
from fastapi import Request
from pydantic_settings import BaseSettings, SettingsConfigDict
if TYPE_CHECKING:
from app.models.app_settings import AppSettings
env_file = Path(__file__).parent.parent / ".env"
class Settings(BaseSettings):
"""Application settings loaded from environment variables."""
"""Bootstrap settings loaded from environment variables.
app_name: str = "Myst"
database_url: str = "postgresql+asyncpg://myst:myst@db:5432/myst_db" # Default for Docker Compose; override with DATABASE_URL env var in production
forgejo_base_url: str = ""
forgejo_oauth_client_id: str = ""
forgejo_oauth_client_secret: SecretStr = SecretStr("")
# Public Myst base URL for OAuth redirect_uri (no trailing slash). If empty, Request.base_url is used.
myst_public_base_url: str = ""
# URL-safe base64 Fernet key (see `cryptography.fernet.Fernet.generate_key()`). Required to persist OAuth tokens and user PATs.
token_encryption_key: SecretStr = SecretStr("")
Only contains fields needed before the database is available.
Forgejo config lives in the AppSettings DB table after setup.
"""
model_config: ClassVar[SettingsConfigDict] = SettingsConfigDict(env_file=str(env_file))
app_name: str = "Firebreak"
database_url: str = "postgresql+asyncpg://firebreak:firebreak@db:5432/firebreak_db"
model_config = SettingsConfigDict(env_file=str(env_file))
@lru_cache
def get_settings() -> Settings:
"""Cached settings instance."""
return Settings()
def get_app_settings(request: Request) -> AppSettings:
"""FastAPI dependency returning the AppSettings row from app state."""
return request.app.state.app_settings

View file

@ -2,57 +2,68 @@ from contextlib import asynccontextmanager
from pathlib import Path
from typing import Annotated
from fastapi import Depends, FastAPI, Form, HTTPException, Request, status
from fastapi.responses import RedirectResponse
from fastapi import Depends, FastAPI, Request
from fastapi.responses import HTMLResponse
from fastapi.staticfiles import StaticFiles
from jinja2_fragments.fastapi import Jinja2Blocks
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
from app import models as _models # noqa: F401 - register ORM tables on metadata
from app.auth.crypto import encrypt_optional, fernet_from_encryption_key
from app.auth.session import get_current_session, get_optional_session
from app.config import Settings, get_settings
from app.config import get_settings
from app.database import Base
from app.deps import get_db
from app.middleware import SetupRequiredMiddleware
from app.models.app_settings import AppSettings
from app.models.session import Session as UserBrowserSession
from app.routers import auth, links
TEMPLATES_DIR = Path(__file__).parent / "templates"
from app.routers import auth, links, settings, setup
from app.templating import templates
@asynccontextmanager
async def lifespan(app: FastAPI):
"""Manage database engine lifecycle."""
settings = get_settings()
"""Manage database engine lifecycle and load app settings."""
boot_settings = get_settings()
engine = create_async_engine(
url=settings.database_url,
url=boot_settings.database_url,
pool_pre_ping=True,
echo=settings.app_name != "Myst",
echo=boot_settings.app_name != "Firebreak",
)
app.state.db_session = async_sessionmaker(
engine,
class_=AsyncSession,
expire_on_commit=False, # Prevents MissingGreenlet in async
expire_on_commit=False,
)
async with engine.begin() as conn:
await conn.run_sync(Base.metadata.create_all) # Create all tables on startup
await conn.run_sync(Base.metadata.create_all)
async with app.state.db_session() as db:
result = await db.execute(select(AppSettings).where(AppSettings.id == 1))
row = result.scalar_one_or_none()
if row:
app.state.setup_complete = True
app.state.app_settings = row
else:
app.state.setup_complete = False
app.state.app_settings = None
yield
await engine.dispose() # Close all connections on shutdown
await engine.dispose()
templates = Jinja2Blocks(directory=str(TEMPLATES_DIR))
app = FastAPI(lifespan=lifespan)
app.add_middleware(SetupRequiredMiddleware)
app.mount("/static", StaticFiles(directory=Path(__file__).parent / "static"), name="static")
app.include_router(auth.router)
app.include_router(links.router)
app.include_router(settings.router)
app.include_router(setup.router)
@app.get("/")
@app.get("/", response_class=HTMLResponse)
async def root(
request: Request, sess: Annotated[UserBrowserSession | None, Depends(get_optional_session)]
):
) -> HTMLResponse:
return templates.TemplateResponse(
request,
"index.html",
@ -60,38 +71,15 @@ async def root(
)
@app.get("/dashboard")
@app.get("/dashboard", response_class=HTMLResponse)
async def dashboard(
request: Request, sess: Annotated[UserBrowserSession, Depends(get_current_session)]
):
) -> HTMLResponse:
return templates.TemplateResponse(
request,
"dashboard.html",
{
"user": sess.user,
"pat_registered": request.query_params.get("pat") == "registered",
"pat_registered": sess.user.has_pat,
},
)
@app.post("/dashboard/pat")
async def register_pat(
pat: Annotated[str, Form()],
db: Annotated[AsyncSession, Depends(get_db)],
settings: Annotated[Settings, Depends(get_settings)],
sess: Annotated[UserBrowserSession, Depends(get_current_session)],
) -> RedirectResponse:
pat = pat.strip()
if not pat:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST, detail="Forgejo access token is required."
)
fernet = fernet_from_encryption_key(settings.token_encryption_key)
sess.user.pat_encrypted = encrypt_optional(fernet, pat)
await db.commit()
return RedirectResponse(
"/dashboard?pat=registered#forgejo-access-token",
status_code=status.HTTP_303_SEE_OTHER,
)

25
web/app/middleware.py Normal file
View file

@ -0,0 +1,25 @@
from starlette.middleware.base import BaseHTTPMiddleware
from starlette.requests import Request
from starlette.responses import RedirectResponse, Response
class SetupRequiredMiddleware(BaseHTTPMiddleware):
"""Redirect all requests to /setup when the app has not been configured yet."""
async def dispatch(self, request: Request, call_next) -> Response:
path = request.url.path
if (
path.startswith("/setup")
or path.startswith("/static")
or path == "/favicon.ico"
):
return await call_next(request)
if not request.app.state.setup_complete:
if request.headers.get("HX-Request"):
response = Response(status_code=200)
response.headers["HX-Redirect"] = "/setup"
return response
return RedirectResponse("/setup", status_code=302)
return await call_next(request)

View file

@ -1,7 +1,8 @@
"""Import ORM modules so ``Base.metadata`` is populated before ``create_all``."""
from app.models.app_settings import AppSettings
from app.models.grant import Grant
from app.models.session import Session
from app.models.user import LinkedIdentity, User
__all__ = ["Grant", "LinkedIdentity", "Session", "User"]
__all__ = ["AppSettings", "Grant", "LinkedIdentity", "Session", "User"]

View file

@ -0,0 +1,38 @@
from __future__ import annotations
import datetime
from cryptography.fernet import Fernet
from pydantic import SecretStr
from sqlalchemy import CheckConstraint, DateTime, String, Text, func
from sqlalchemy.orm import Mapped, mapped_column
from app.auth.crypto import fernet_from_encryption_key
from app.database import Base
class AppSettings(Base):
__tablename__ = "app_settings"
__table_args__ = (CheckConstraint("id = 1", name="single_row"),)
id: Mapped[int] = mapped_column(primary_key=True, default=1)
forgejo_base_url: Mapped[str] = mapped_column(String, nullable=False)
forgejo_oauth_client_id: Mapped[str] = mapped_column(String, nullable=False)
forgejo_oauth_client_secret_encrypted: Mapped[str] = mapped_column(Text, nullable=False)
firebreak_public_base_url: Mapped[str] = mapped_column(String, nullable=False, default="")
token_encryption_key: Mapped[str] = mapped_column(Text, nullable=False)
setup_completed_at: Mapped[datetime.datetime] = mapped_column(
DateTime(timezone=True), server_default=func.now()
)
__allow_unmapped__ = True
_fernet: Fernet | None = None
def get_fernet(self) -> Fernet:
"""Return a cached Fernet cipher from the stored encryption key."""
if self._fernet is None:
fernet = fernet_from_encryption_key(SecretStr(self.token_encryption_key))
if fernet is None:
raise ValueError("Token encryption key is missing or empty in app settings.")
self._fernet = fernet
return self._fernet

View file

@ -23,8 +23,13 @@ class User(Base):
display_name: Mapped[str | None] = mapped_column(String, nullable=True)
email: Mapped[str | None] = mapped_column(String, nullable=True, index=True)
pat_encrypted: Mapped[str | None] = mapped_column(Text, nullable=True)
pat_registered_at: Mapped[datetime | None] = mapped_column(nullable=True)
created_at: Mapped[datetime] = mapped_column(server_default=func.now())
@property
def has_pat(self) -> bool:
return self.pat_encrypted is not None
identities: Mapped[list[LinkedIdentity]] = relationship(
back_populates="user",
cascade="all, delete-orphan",

View file

@ -6,14 +6,16 @@ from typing import Annotated
from urllib.parse import urlencode
import httpx
from fastapi import APIRouter, Cookie, Depends, HTTPException, Request, Response, status
from fastapi import APIRouter, Cookie, Depends, HTTPException, Request, status
from fastapi.responses import RedirectResponse
from sqlalchemy.ext.asyncio import AsyncSession
from app.auth.crypto import decrypt_token
from app.auth.identity import find_or_create_user
from app.auth.session import create_session, revoke_session
from app.config import Settings, get_settings
from app.config import get_app_settings
from app.deps import get_db
from app.models.app_settings import AppSettings
router = APIRouter(prefix="/auth", tags=["auth"])
@ -21,44 +23,38 @@ router = APIRouter(prefix="/auth", tags=["auth"])
# ── Forgejo API client ──
async def _forgejo_post(settings: Settings, path: str, data: dict) -> dict:
"""POST form data to a Forgejo API path and return the JSON response."""
# Keep Forgejo HTTP calls in small helpers so route handlers read as the
# OAuth flow instead of low-level request/response plumbing.
url = f"{settings.forgejo_base_url.rstrip('/')}{path}"
async def _forgejo_post(app_settings: AppSettings, path: str, data: dict) -> dict:
url = f"{app_settings.forgejo_base_url}{path}"
try:
async with httpx.AsyncClient(timeout=30.0) as client:
resp = await client.post(url, data=data, headers={"Accept": "application/json"})
except httpx.RequestError as exc:
except httpx.RequestError:
raise HTTPException(
status_code=status.HTTP_502_BAD_GATEWAY,
detail=f"Cannot reach Forgejo: {exc}",
) from exc
detail="Cannot reach Forgejo. Check your connection settings.",
)
if resp.status_code != 200:
raise HTTPException(
status_code=status.HTTP_502_BAD_GATEWAY,
detail=(f"Forgejo API error {resp.status_code} at {path}: {resp.text[:500]}"),
detail=f"Forgejo returned an error ({resp.status_code}). Verify your OAuth configuration.",
)
return resp.json()
async def _forgejo_get(settings: Settings, path: str, token: str) -> dict:
"""GET a Forgejo API path with a provider access token."""
url = f"{settings.forgejo_base_url.rstrip('/')}{path}"
async def _forgejo_get(app_settings: AppSettings, path: str, token: str) -> dict:
url = f"{app_settings.forgejo_base_url}{path}"
try:
async with httpx.AsyncClient(timeout=30.0) as client:
resp = await client.get(url, headers={"Authorization": f"token {token}"})
except httpx.RequestError as exc:
except httpx.RequestError:
raise HTTPException(
status_code=status.HTTP_502_BAD_GATEWAY,
detail=f"Cannot reach Forgejo: {exc}",
) from exc
detail="Cannot reach Forgejo. Check your connection settings.",
)
if resp.status_code != 200:
raise HTTPException(
status_code=status.HTTP_502_BAD_GATEWAY,
detail=(f"Forgejo API error {resp.status_code} at {path}: {resp.text[:500]}"),
detail=f"Forgejo returned an error ({resp.status_code}). Verify your OAuth configuration.",
)
return resp.json()
@ -66,11 +62,7 @@ async def _forgejo_get(settings: Settings, path: str, token: str) -> dict:
# ── OAuth CSRF helpers ──
def _set_oauth_state_cookie(response: Response, state: str) -> None:
"""Set the short-lived OAuth state cookie used to verify the callback."""
# Store the OAuth state server-to-browser only. The callback must echo this
# value back, which ties the callback to the login request we initiated.
def _set_oauth_state_cookie(response: RedirectResponse, state: str) -> None:
response.set_cookie(
key="oauth_state",
value=state,
@ -82,10 +74,6 @@ def _set_oauth_state_cookie(response: Response, state: str) -> None:
def _verify_oauth_state(state: str | None, oauth_state: str | None) -> None:
"""Validate the OAuth state query parameter against the stored cookie."""
# Use constant-time comparison because this value is part of the CSRF
# defense for the OAuth redirect flow.
if not state or not oauth_state or not secrets.compare_digest(state, oauth_state):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
@ -97,10 +85,6 @@ def _verify_oauth_state(state: str | None, oauth_state: str | None) -> None:
def _parse_token_response(data: dict) -> tuple[str, str | None, datetime | None]:
"""Extract access token, refresh token, and expiry from Forgejo OAuth data."""
# Forgejo's token response is external input, so normalize it before the
# rest of the app stores or relies on any values.
access_token = data.get("access_token")
if not access_token or not isinstance(access_token, str):
raise HTTPException(
@ -118,10 +102,6 @@ def _parse_token_response(data: dict) -> tuple[str, str | None, datetime | None]
def _parse_user_response(data: dict) -> tuple[str, str, str | None]:
"""Extract the Forgejo identity fields needed for local user linking."""
# Provider id and username are the stable link between Forgejo and our local
# user record. Email is optional because providers may omit or hide it.
provider_user_id = str(data.get("id", "")).strip()
provider_username = str(data.get("username", "")).strip()
if not provider_user_id or not provider_username:
@ -137,37 +117,20 @@ def _parse_user_response(data: dict) -> tuple[str, str, str | None]:
# ── OAuth config helpers ──
def _forgejo_oauth_redirect_uri(request: Request, settings: Settings) -> str:
"""Return the callback URL registered with Forgejo for this request."""
# In production, prefer the configured public base URL so Forgejo sees the
# same callback URL users do. Locally, fall back to FastAPI's generated URL.
base_url = settings.myst_public_base_url.strip().rstrip("/")
def _forgejo_oauth_redirect_uri(request: Request, app_settings: AppSettings) -> str:
base_url = app_settings.firebreak_public_base_url.strip().rstrip("/")
if base_url:
return f"{base_url}/auth/callback/forgejo"
return str(request.url_for("forgejo_oauth_callback"))
def _require_forgejo_oauth_config(settings: Settings) -> None:
"""Raise a setup error when the Forgejo OAuth settings are incomplete."""
# Fail before redirecting when OAuth is only partially configured. This gives
# a clearer setup error than a failed request after the user leaves the app.
if not settings.forgejo_base_url.strip():
def _get_oauth_client_secret(app_settings: AppSettings) -> str:
try:
return decrypt_token(app_settings.get_fernet(), app_settings.forgejo_oauth_client_secret_encrypted)
except ValueError:
raise HTTPException(
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
detail="Forgejo is not configured: set FORGEJO_BASE_URL in the environment.",
)
if not settings.forgejo_oauth_client_id.strip():
raise HTTPException(
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
detail="Forgejo OAuth is not configured: set FORGEJO_OAUTH_CLIENT_ID in the environment.",
)
secret = settings.forgejo_oauth_client_secret.get_secret_value().strip()
if not secret:
raise HTTPException(
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
detail="Forgejo OAuth is not configured: set FORGEJO_OAUTH_CLIENT_SECRET in the environment.",
detail="Forgejo OAuth credentials could not be decrypted. Reconfigure at /setup.",
)
@ -176,25 +139,21 @@ def _require_forgejo_oauth_config(settings: Settings) -> None:
@router.get("/login/forgejo")
async def login_forgejo(
request: Request, settings: Annotated[Settings, Depends(get_settings)]
request: Request, app_settings: Annotated[AppSettings, Depends(get_app_settings)]
) -> RedirectResponse:
"""Redirect the browser to Forgejo to begin OAuth sign-in."""
_require_forgejo_oauth_config(settings)
# Start the OAuth authorization-code flow. Forgejo receives our callback URL
# and the random state value; the user's browser is redirected there next.
redirect_uri = _forgejo_oauth_redirect_uri(request, settings)
redirect_uri = _forgejo_oauth_redirect_uri(request, app_settings)
state = secrets.token_urlsafe(32)
query = urlencode(
{
"client_id": settings.forgejo_oauth_client_id,
"client_id": app_settings.forgejo_oauth_client_id,
"response_type": "code",
"redirect_uri": redirect_uri,
"state": state,
}
)
authorization_url = f"{settings.forgejo_base_url.rstrip('/')}/login/oauth/authorize?{query}"
authorization_url = f"{app_settings.forgejo_base_url}/login/oauth/authorize?{query}"
response = RedirectResponse(authorization_url, status_code=status.HTTP_302_FOUND)
_set_oauth_state_cookie(response, state)
return response
@ -204,16 +163,13 @@ async def login_forgejo(
async def callback_forgejo(
request: Request,
db: Annotated[AsyncSession, Depends(get_db)],
settings: Annotated[Settings, Depends(get_settings)],
app_settings: Annotated[AppSettings, Depends(get_app_settings)],
code: str | None = None,
state: str | None = None,
oauth_state: Annotated[str | None, Cookie()] = None,
) -> RedirectResponse:
"""Handle Forgejo's OAuth callback and create a local app session."""
_require_forgejo_oauth_config(settings)
# The callback must include the same state value we put in the cookie during
# login, otherwise this could be an unsolicited OAuth response.
_verify_oauth_state(state, oauth_state)
if not code:
@ -222,37 +178,28 @@ async def callback_forgejo(
detail="Forgejo did not return an authorization code. The user may have denied consent.",
)
# Build the response before session creation so the session cookie is set on
# the exact RedirectResponse returned to the browser.
redirect = RedirectResponse("/dashboard", status_code=status.HTTP_302_FOUND)
redirect.delete_cookie("oauth_state")
client_secret = _get_oauth_client_secret(app_settings)
redirect_uri = _forgejo_oauth_redirect_uri(request, app_settings)
# Exchange Forgejo's short-lived authorization code for provider tokens.
# These tokens identify the Forgejo account, but they are not our app
# session cookie.
token_data = await _forgejo_post(
settings,
app_settings,
"/login/oauth/access_token",
{
"grant_type": "authorization_code",
"client_id": settings.forgejo_oauth_client_id,
"client_secret": settings.forgejo_oauth_client_secret.get_secret_value(),
"client_id": app_settings.forgejo_oauth_client_id,
"client_secret": client_secret,
"code": code,
"redirect_uri": _forgejo_oauth_redirect_uri(request, settings),
"redirect_uri": redirect_uri,
},
)
access_token, refresh_plain, expires_at = _parse_token_response(token_data)
# Use the provider access token once to fetch the Forgejo account profile we
# link to our local users table.
user_data = await _forgejo_get(settings, "/api/v1/user", access_token)
user_data = await _forgejo_get(app_settings, "/api/v1/user", access_token)
provider_user_id, provider_username, email = _parse_user_response(user_data)
# Upsert the local user and linked identity. Provider tokens are encrypted
# before they are stored by find_or_create_user.
user = await find_or_create_user(
db,
settings,
app_settings,
provider="forgejo",
provider_user_id=provider_user_id,
provider_username=provider_username,
@ -262,8 +209,10 @@ async def callback_forgejo(
refresh_token_raw=refresh_plain,
)
# After OAuth succeeds, use our own session cookie for normal app requests.
# The raw cookie value is sent to the browser; only its hash is stored.
target = "/dashboard" if user.has_pat else "/settings"
redirect = RedirectResponse(target, status_code=status.HTTP_302_FOUND)
redirect.delete_cookie("oauth_state")
await create_session(db, redirect, user.id, secure=request.url.scheme == "https")
return redirect
@ -271,12 +220,10 @@ async def callback_forgejo(
@router.get("/logout")
async def logout(
db: Annotated[AsyncSession, Depends(get_db)],
myst_session: Annotated[str | None, Cookie()] = None,
firebreak_session: Annotated[str | None, Cookie()] = None,
) -> RedirectResponse:
"""Revoke the current app session and redirect back to the home page."""
# revoke_session must receive this redirect response, otherwise the
# Set-Cookie delete header would be written to an unused Response object.
redirect = RedirectResponse("/", status_code=status.HTTP_302_FOUND)
await revoke_session(db, redirect, myst_session)
await revoke_session(db, redirect, firebreak_session)
return redirect

View file

@ -25,6 +25,7 @@ class CreateLinkResponse(BaseModel):
share_url: str
@router.post("/", response_model=CreateLinkResponse)
async def create_link(request: CreateLinkRequest):
pass
@router.post("/", status_code=501)
async def create_link(request: CreateLinkRequest) -> dict:
"""Stub — link creation not yet implemented."""
return {"detail": "Link creation is not yet implemented."}

View file

@ -0,0 +1,76 @@
from __future__ import annotations
from datetime import UTC, datetime
from typing import Annotated
from fastapi import APIRouter, Depends, Form, HTTPException, Request, status
from fastapi.responses import HTMLResponse, RedirectResponse
from sqlalchemy.ext.asyncio import AsyncSession
from app.auth.crypto import encrypt_optional
from app.auth.session import get_current_session
from app.config import get_app_settings
from app.deps import get_db
from app.models.app_settings import AppSettings
from app.models.session import Session as UserBrowserSession
from app.templating import templates
router = APIRouter(prefix="/settings", tags=["settings"])
@router.get("", response_class=HTMLResponse)
async def settings_page(
request: Request,
sess: Annotated[UserBrowserSession, Depends(get_current_session)],
app_settings: Annotated[AppSettings, Depends(get_app_settings)],
) -> HTMLResponse:
return templates.TemplateResponse(
request,
"settings.html",
{
"user": sess.user,
"pat_registered": sess.user.has_pat,
"pat_registered_at": sess.user.pat_registered_at,
"pat_deleted": request.query_params.get("pat") == "deleted",
},
)
@router.post("/pat")
async def register_pat(
pat: Annotated[str, Form()],
db: Annotated[AsyncSession, Depends(get_db)],
app_settings: Annotated[AppSettings, Depends(get_app_settings)],
sess: Annotated[UserBrowserSession, Depends(get_current_session)],
) -> RedirectResponse:
pat = pat.strip()
if not pat:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Forgejo access token is required.",
)
fernet = app_settings.get_fernet()
sess.user.pat_encrypted = encrypt_optional(fernet, pat)
sess.user.pat_registered_at = datetime.now(UTC)
await db.commit()
return RedirectResponse(
"/settings?pat=registered",
status_code=status.HTTP_303_SEE_OTHER,
)
@router.post("/pat/delete")
async def delete_pat(
db: Annotated[AsyncSession, Depends(get_db)],
sess: Annotated[UserBrowserSession, Depends(get_current_session)],
) -> RedirectResponse:
sess.user.pat_encrypted = None
sess.user.pat_registered_at = None
await db.commit()
return RedirectResponse(
"/settings?pat=deleted",
status_code=status.HTTP_303_SEE_OTHER,
)

117
web/app/routers/setup.py Normal file
View file

@ -0,0 +1,117 @@
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)

View file

@ -204,6 +204,10 @@
color: #fffdf8;
}
.landing-page .app-header {
display: none;
}
.landing-page {
background: #17191c;
}

View file

@ -4,7 +4,7 @@
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>
{% block title %}Myst{% endblock %}
{% block title %}Firebreak{% endblock %}
</title>
<link rel="preconnect" href="https://fonts.googleapis.com" />
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
@ -56,6 +56,7 @@
<nav class="flex items-center gap-2">
{% if user %}
<a href="/dashboard" class="btn btn-sm btn-borderless">Dashboard</a>
<a href="/settings" class="btn btn-sm btn-borderless">Settings</a>
<a href="/auth/logout" class="btn btn-sm btn-secondary">Logout</a>
{% else %}
<a href="/auth/login/forgejo" class="btn btn-sm btn-primary">
@ -71,7 +72,7 @@
</nav>
</div>
</header>
<main class="px-4 py-8 mx-auto max-w-7xl sm:px-8">
<main class="{% block main_class %}px-4 py-8 mx-auto max-w-7xl sm:px-8{% endblock %}">
{% block content %}{% endblock %}
</main>
</body>

View file

@ -1,5 +1,5 @@
{% extends "base.html" %}
{% block title %}Dashboard — Myst{% endblock %}
{% block title %}Dashboard — Firebreak{% endblock %}
{% block content %}
<div class="flex flex-col gap-6">
<section class="flex flex-col justify-between gap-4 pb-6 border-b border-border sm:flex-row sm:items-end">
@ -26,29 +26,15 @@
<p class="mt-2 text-xs text-muted-foreground">Viewer activity will appear here.</p>
</div>
</section>
<div id="forgejo-access-token">
{% if pat_registered %}
<div
class="mt-3 rounded-md border-l-4 border-success bg-success-muted px-4 py-3 text-sm font-semibold text-success-foreground"
role="status">Forgejo access token registered.</div>
{% else %}
<h2 class="text-base font-semibold">Forgejo access token</h2>
<p class="mt-2 text-sm text-muted-foreground">
Register a <code class="rounded-sm bg-secondary px-1.5 py-0.5 text-primary">read:repository</code>-scoped PAT
to enable share link viewing.
{% if not pat_registered %}
<div class="rounded-lg border border-warning-muted bg-warning-muted/40 px-5 py-4">
<p class="text-sm font-semibold text-warning-foreground">Access token required</p>
<p class="mt-1 text-sm text-muted-foreground">
Register a Forgejo access token to create share links.
</p>
<form id="pat-form" class="mt-4" method="post" action="/dashboard/pat" novalidate>
<div class="grid gap-2 sm:gap-4 sm:grid-cols-[1fr_auto] sm:items-end">
<input type="text" id="pat" name="pat" class="block w-full input-mono" placeholder="ad8j3..."
aria-describedby="pat-error" aria-invalid="false" required />
<button type="submit" class="btn btn-sm btn-primary self-center">Register</button>
</div>
<div class="mt-2">
<p id="pat-error" class="input-error hidden">A Forgejo token is required.</p>
</div>
</form>
{% endif %}
<a href="/settings" class="btn btn-sm btn-primary mt-3 w-fit">Go to Settings</a>
</div>
{% endif %}
<div class="space-y-3">
<div>
<h2 class="text-base font-semibold">Share links</h2>
@ -76,34 +62,4 @@
</section>
</div>
</div>
<script>
(() => {
const form = document.getElementById("pat-form");
const input = document.getElementById("pat");
const error = document.getElementById("pat-error");
if (!form || !input || !error) return;
const showError = () => {
input.setAttribute("aria-invalid", "true");
input.classList.add("border-danger", "focus:border-danger", "focus:ring-danger-muted");
error.classList.remove("hidden");
input.focus();
};
const clearError = () => {
input.setAttribute("aria-invalid", "false");
input.classList.remove("border-danger", "focus:border-danger", "focus:ring-danger-muted");
error.classList.add("hidden");
};
form.addEventListener("submit", (event) => {
if (input.value.trim()) return;
event.preventDefault();
showError();
});
input.addEventListener("input", clearError);
})();
</script>
{% endblock %}

View file

@ -1,8 +1,9 @@
{% extends "base.html" %}
{% block title %}Firebreak — protect your code from scraping{% endblock %}
{% block body_class %}landing-page{% endblock %}
{% block main_class %}{% endblock %}
{% block content %}
<section class="relative left-1/2 right-1/2 -mx-[50vw] -mt-8 -mb-8 flex min-h-[calc(100dvh-4.25rem)] w-screen items-center justify-center overflow-hidden bg-[#17191c] px-6 py-20 text-center text-[#f7f2e8]">
<section class="relative flex min-h-dvh w-full items-center justify-center overflow-hidden bg-[#17191c] px-6 py-20 text-center text-[#f7f2e8]">
<video class="absolute inset-0 h-full w-full object-cover"
autoplay
muted
@ -45,6 +46,10 @@
</a>
{% endif %}
</div>
<a href="/setup"
class="mt-5 text-xs text-[#f7f2e8]/30 hover:text-[#f7f2e8]/60 hover:underline decoration-1 underline-offset-4 transition">
Reconfigure Forgejo connection
</a>
</div>
</section>
{% endblock %}

View file

@ -0,0 +1,134 @@
{% extends "base.html" %}
{% block title %}Settings — Firebreak{% endblock %}
{% block content %}
<div class="flex flex-col gap-6">
<section class="pb-6 border-b border-border">
<h1 class="text-2xl font-semibold">Settings</h1>
<p class="mt-2 text-sm text-muted-foreground">Manage your Firebreak configuration.</p>
</section>
{% if pat_deleted %}
<div class="rounded-md border-l-4 border-warning bg-warning-muted px-4 py-3 text-sm font-semibold text-warning-foreground"
role="status">Access token removed.</div>
{% endif %}
<div id="forgejo-access-token">
<h2 class="text-base font-semibold">Forgejo access token</h2>
<p class="mt-2 text-sm text-muted-foreground">
A <code class="rounded-sm bg-secondary px-1.5 py-0.5 text-foreground">read:repository</code>-scoped
Personal Access Token is required for share link viewing.
</p>
{% if pat_registered %}
<div class="mt-4 card">
<div class="flex items-center justify-between px-4 py-3.5">
<div class="flex items-center gap-3">
<div class="flex size-8 items-center justify-center rounded-md bg-success-muted text-success-foreground">
<svg xmlns="http://www.w3.org/2000/svg"
width="16"
height="16"
viewBox="0 0 24 24"
fill="none"
stroke="currentColor"
stroke-width="2"
stroke-linecap="round"
stroke-linejoin="round">
<path d="M21 2l-2 2m-7.61 7.61a5.5 5.5 0 1 1-7.778 7.778 5.5 5.5 0 0 1 7.777-7.777zm0 0L15.5 7.5m0 0l3 3L22 7l-3-3m-3.5 3.5L19 4" />
</svg>
</div>
<div>
<p class="text-sm font-medium text-foreground">Access token</p>
<p class="mt-0.5 text-xs text-muted-foreground">
{% if pat_registered_at %}
Registered {{ pat_registered_at.strftime("%b %d, %Y") }}
{% else %}
Registered
{% endif %}
</p>
</div>
</div>
<form method="post" action="/settings/pat/delete">
<button type="submit"
class="btn btn-xs btn-secondary text-danger-foreground hover:bg-danger-muted hover:border-danger-muted">
Delete
</button>
</form>
</div>
</div>
<details class="mt-4">
<summary class="cursor-pointer text-sm text-muted-foreground hover:text-foreground">
Update token
</summary>
<form id="pat-form"
class="mt-3"
method="post"
action="/settings/pat"
novalidate>
<div class="grid gap-2 sm:gap-4 sm:grid-cols-[1fr_auto] sm:items-end">
<input type="password"
id="pat"
name="pat"
class="block w-full input-mono"
placeholder="Paste new token..."
aria-describedby="pat-error"
aria-invalid="false"
required />
<button type="submit" class="btn btn-sm btn-primary self-center">Update</button>
</div>
<div class="mt-2">
<p id="pat-error" class="input-error hidden">A Forgejo token is required.</p>
</div>
</form>
</details>
{% else %}
<form id="pat-form"
class="mt-4"
method="post"
action="/settings/pat"
novalidate>
<div class="grid gap-2 sm:gap-4 sm:grid-cols-[1fr_auto] sm:items-end">
<input type="password"
id="pat"
name="pat"
class="block w-full input-mono"
placeholder="ad8j3..."
aria-describedby="pat-error"
aria-invalid="false"
required />
<button type="submit" class="btn btn-sm btn-primary self-center">Register</button>
</div>
<div class="mt-2">
<p id="pat-error" class="input-error hidden">A Forgejo token is required.</p>
</div>
</form>
{% endif %}
</div>
</div>
<script>
(() => {
const form = document.getElementById("pat-form");
const input = document.getElementById("pat");
const error = document.getElementById("pat-error");
if (!form || !input || !error) return;
const showError = () => {
input.setAttribute("aria-invalid", "true");
input.classList.add("border-danger", "focus:border-danger", "focus:ring-danger-muted");
error.classList.remove("hidden");
input.focus();
};
const clearError = () => {
input.setAttribute("aria-invalid", "false");
input.classList.remove("border-danger", "focus:border-danger", "focus:ring-danger-muted");
error.classList.add("hidden");
};
form.addEventListener("submit", (event) => {
if (input.value.trim()) return;
event.preventDefault();
showError();
});
input.addEventListener("input", clearError);
})();
</script>
{% endblock %}

View file

@ -0,0 +1,118 @@
{% extends "base.html" %}
{% block title %}{{ "Reconfigure" if reconfiguring else "Setup" }} — Firebreak{% endblock %}
{% block body_class %}landing-page{% endblock %}
{% block main_class %}{% endblock %}
{% block content %}
<section class="flex min-h-dvh items-center justify-center px-6 py-20">
<div class="w-full max-w-lg">
<div class="mb-8 text-center">
<img src="/static/img/firebreak-brand.svg"
alt="Firebreak"
width="240"
height="268"
class="mx-auto h-auto w-full max-w-24" />
<h1 class="mt-6 text-2xl font-semibold text-[#f7f2e8]">
{{ "Reconfigure" if reconfiguring else "Setup" }}
</h1>
{% if reconfiguring %}
<p class="mt-2 text-sm leading-6 text-[#f7f2e8]/60">
Update your Forgejo OAuth connection. Make sure the OAuth application
is registered in your Forgejo instance before continuing.
</p>
{% else %}
<p class="mt-2 text-sm leading-6 text-[#f7f2e8]/60">
Connect Firebreak to your Forgejo instance. You'll need to
<a href="https://forgejo.org/docs/latest/user/oauth2-provider/"
target="_blank"
rel="noopener"
class="underline underline-offset-2 text-[#f7f2e8]/80 hover:text-[#f7f2e8]">register an OAuth application</a>
in Forgejo first.
</p>
{% endif %}
</div>
{% if not reconfiguring %}
<div class="mb-8 rounded-lg border border-[#f7f2e8]/10 bg-[#1f2226]/60 px-5 py-4 text-xs leading-5 text-[#f7f2e8]/50">
<p class="font-medium text-[#f7f2e8]/70 mb-2.5">How to get your OAuth credentials:</p>
<ol class="list-decimal list-inside space-y-1.5">
<li>
In Forgejo, go to <strong class="text-[#f7f2e8]/70">Settings &rarr; Applications</strong>
</li>
<li>
Under <strong class="text-[#f7f2e8]/70">Manage OAuth2 Applications</strong>, create a new app
</li>
<li>
Set the redirect URI to
<br />
<code class="mt-1 inline-block rounded bg-[#f7f2e8]/8 px-1.5 py-0.5 font-mono text-[10px] text-[#f7f2e8]/60">http://localhost:8000/auth/callback/forgejo</code>
</li>
<li>
Copy the <strong class="text-[#f7f2e8]/70">Client ID</strong> and <strong class="text-[#f7f2e8]/70">Client Secret</strong> into the form below
</li>
</ol>
</div>
{% endif %}
<form method="post" action="/setup" class="space-y-5">
<div>
<label for="forgejo_base_url"
class="block text-xs font-semibold uppercase tracking-[0.05em] text-[#f7f2e8]/50 mb-1.5">
Forgejo Instance URL
</label>
<input type="url"
id="forgejo_base_url"
name="forgejo_base_url"
class="block w-full rounded-md border border-[#f7f2e8]/14 bg-[#1f2226] px-3 py-2.5 text-sm text-[#f7f2e8] placeholder:text-[#f7f2e8]/30 focus:border-[#f7f2e8]/30 focus:outline-none focus:ring-2 focus:ring-[#f7f2e8]/10"
placeholder="https://git.example.com"
value="{{ forgejo_base_url }}"
required />
</div>
<div>
<label for="forgejo_oauth_client_id"
class="block text-xs font-semibold uppercase tracking-[0.05em] text-[#f7f2e8]/50 mb-1.5">
OAuth Client ID
</label>
<input type="text"
id="forgejo_oauth_client_id"
name="forgejo_oauth_client_id"
class="block w-full rounded-md border border-[#f7f2e8]/14 bg-[#1f2226] px-3 py-2.5 font-mono text-sm text-[#f7f2e8] placeholder:text-[#f7f2e8]/30 focus:border-[#f7f2e8]/30 focus:outline-none focus:ring-2 focus:ring-[#f7f2e8]/10"
placeholder="c8ab3315-537d-44f3-..."
value="{{ forgejo_oauth_client_id }}"
required />
</div>
<div>
<label for="forgejo_oauth_client_secret"
class="block text-xs font-semibold uppercase tracking-[0.05em] text-[#f7f2e8]/50 mb-1.5">
OAuth Client Secret
{% if reconfiguring %}
<span class="ml-1 normal-case tracking-normal font-normal text-[#f7f2e8]/30">(leave blank to keep current)</span>
{% endif %}
</label>
<input type="password"
id="forgejo_oauth_client_secret"
name="forgejo_oauth_client_secret"
class="block w-full rounded-md border border-[#f7f2e8]/14 bg-[#1f2226] px-3 py-2.5 font-mono text-sm text-[#f7f2e8] placeholder:text-[#f7f2e8]/30 focus:border-[#f7f2e8]/30 focus:outline-none focus:ring-2 focus:ring-[#f7f2e8]/10"
placeholder="gto_wkxxnv4ewa..."
{{ "" if reconfiguring else "required" }} />
</div>
<div>
<label for="firebreak_public_base_url"
class="block text-xs font-semibold uppercase tracking-[0.05em] text-[#f7f2e8]/50 mb-1.5">
Public Base URL
<span class="ml-1 normal-case tracking-normal font-normal text-[#f7f2e8]/30">(optional)</span>
</label>
<input type="url"
id="firebreak_public_base_url"
name="firebreak_public_base_url"
class="block w-full rounded-md border border-[#f7f2e8]/14 bg-[#1f2226] px-3 py-2.5 text-sm text-[#f7f2e8] placeholder:text-[#f7f2e8]/30 focus:border-[#f7f2e8]/30 focus:outline-none focus:ring-2 focus:ring-[#f7f2e8]/10"
placeholder="https://share.example.com"
value="{{ firebreak_public_base_url }}" />
<p class="mt-1.5 text-xs text-[#f7f2e8]/30">
Your production domain for OAuth redirects. Leave blank on localhost &mdash; Firebreak will use <code class="font-mono text-[#f7f2e8]/40">http://localhost:8000</code> automatically.
</p>
</div>
<button type="submit" class="btn btn-primary w-full mt-2">
{{ "Save Forgejo settings" if reconfiguring else "Complete Setup" }}
</button>
</form>
</div>
</section>
{% endblock %}

9
web/app/templating.py Normal file
View file

@ -0,0 +1,9 @@
"""Shared Jinja2 template engine — importable without circular deps."""
from pathlib import Path
from jinja2_fragments.fastapi import Jinja2Blocks
TEMPLATES_DIR = Path(__file__).parent / "templates"
templates = Jinja2Blocks(directory=str(TEMPLATES_DIR))