5081ba00f6
Some checks failed
Build and Push / build (push) Failing after 17s
Backend:
- password hashing via hashlib.scrypt
- stateless HMAC-SHA256 tokens (7-day expiry)
- POST /api/auth/login, /api/auth/register (admin), /api/auth/reset-password
- admin user created from NAT20_ADMIN_USERNAME/PASSWORD on first startup
- users table, campaign_shares table, created_by on campaigns
- require_user dependency on all routes except auth
- campaign sharing: GET/POST/DELETE /api/campaigns/{id}/shares
Frontend:
- AuthContext: user/token state, login/logout, global fetch Auth header
- Login page, Users page (admin user management)
- route protection, sidebar user info/sign out
Docker/CI:
- split backend/Dockerfile into thin app-only image
- backend/Dockerfile.deps builds the heavy WhisperX/PyTorch base
- CI builds deps only when requirements.txt changes
- docker compose pull now fetches ~100KB app layer instead of 3.5GB
123 lines
4.1 KiB
Python
123 lines
4.1 KiB
Python
from pathlib import Path
|
|
|
|
from fastapi import Depends, FastAPI, Request
|
|
from fastapi.middleware.cors import CORSMiddleware
|
|
from fastapi.responses import FileResponse, JSONResponse
|
|
from fastapi import HTTPException
|
|
|
|
from . import database as db, config
|
|
from .logging_config import setup_logging, get_logger
|
|
from .errors import PipelineError
|
|
from .auth import ensure_admin_exists
|
|
from .routers.auth import require_user
|
|
from .routers import auth as auth_router
|
|
from .routers import settings as settings_router
|
|
from .routers import sessions as sessions_router
|
|
from .routers import speakers as speakers_router
|
|
from .routers import notes as notes_router
|
|
from .routers import jobs as jobs_router
|
|
from .routers import models as models_router
|
|
from .routers import diagnostics as diagnostics_router
|
|
from .routers import files as files_router
|
|
from .routers import campaigns as campaigns_router
|
|
|
|
setup_logging()
|
|
log = get_logger(__name__)
|
|
|
|
app = FastAPI(title="Nat20 Notes")
|
|
|
|
app.add_middleware(
|
|
CORSMiddleware,
|
|
allow_origins=["*"],
|
|
allow_methods=["*"],
|
|
allow_headers=["*"],
|
|
)
|
|
|
|
|
|
@app.exception_handler(PipelineError)
|
|
async def pipeline_error_handler(request: Request, exc: PipelineError):
|
|
log.error("Pipeline error in %s: %s", exc.stage, exc.message, exc_info=exc.cause or exc)
|
|
return JSONResponse(status_code=502, content={"stage": exc.stage, "message": exc.message})
|
|
|
|
|
|
@app.exception_handler(Exception)
|
|
async def unhandled_error_handler(request: Request, exc: Exception):
|
|
log.exception("Unhandled error on %s %s", request.method, request.url.path)
|
|
return JSONResponse(status_code=500, content={"stage": "unknown", "message": f"Unexpected error: {exc}"})
|
|
|
|
|
|
@app.on_event("startup")
|
|
def on_startup():
|
|
db.init_db()
|
|
ensure_admin_exists()
|
|
log.info("Database initialized at %s", config.DB_PATH)
|
|
|
|
|
|
app.include_router(auth_router.router)
|
|
app.include_router(settings_router.router, dependencies=[Depends(require_user)])
|
|
app.include_router(sessions_router.router, dependencies=[Depends(require_user)])
|
|
app.include_router(speakers_router.router, dependencies=[Depends(require_user)])
|
|
app.include_router(notes_router.router, dependencies=[Depends(require_user)])
|
|
app.include_router(jobs_router.router, dependencies=[Depends(require_user)])
|
|
app.include_router(models_router.router, dependencies=[Depends(require_user)])
|
|
app.include_router(diagnostics_router.router, dependencies=[Depends(require_user)])
|
|
app.include_router(files_router.router, dependencies=[Depends(require_user)])
|
|
app.include_router(campaigns_router.router, dependencies=[Depends(require_user)])
|
|
|
|
|
|
MEDIA_TYPES = {
|
|
".mp3": "audio/mpeg",
|
|
".mp4": "audio/mp4",
|
|
".m4a": "audio/mp4",
|
|
".m4b": "audio/mp4",
|
|
".ogg": "audio/ogg",
|
|
".opus": "audio/ogg",
|
|
".wav": "audio/wav",
|
|
".flac": "audio/flac",
|
|
".aac": "audio/aac",
|
|
".webm": "audio/webm",
|
|
}
|
|
|
|
AUDIO_EXTS = frozenset(MEDIA_TYPES.keys())
|
|
|
|
|
|
@app.get("/api/sessions/{session_id}/audio")
|
|
def get_audio(session_id: str, user: dict = Depends(require_user)):
|
|
row = db.get_conn().execute(
|
|
"SELECT video_path, audio_path FROM sessions WHERE id = ?", (session_id,)
|
|
).fetchone()
|
|
if not row:
|
|
raise HTTPException(404, "Session not found")
|
|
|
|
# Priority: Opus playback > original upload > extracted WAV.
|
|
# The Opus file is tiny (~65 MB for 3 hours) so the frontend's Blob
|
|
# download completes in seconds on any modern connection.
|
|
candidates = []
|
|
|
|
if row["audio_path"]:
|
|
opus = Path(row["audio_path"]).with_suffix(".opus")
|
|
if opus.exists():
|
|
candidates.append(opus)
|
|
|
|
if row["video_path"]:
|
|
p = Path(row["video_path"])
|
|
if p.exists():
|
|
candidates.append(p)
|
|
|
|
if row["audio_path"]:
|
|
p = Path(row["audio_path"])
|
|
if p.exists():
|
|
candidates.append(p)
|
|
|
|
if not candidates:
|
|
raise HTTPException(404, "No audio file available for this session")
|
|
|
|
chosen = candidates[0]
|
|
ext = chosen.suffix.lower()
|
|
media_type = MEDIA_TYPES.get(ext, "application/octet-stream")
|
|
return FileResponse(chosen, media_type=media_type)
|
|
|
|
|
|
@app.get("/api/health")
|
|
def health():
|
|
return {"ok": True} |