Universal-Sprint: Wizard, UI-Mounts, Encoder-Erkennung, Task-Split, README

Commander-Ziel: All-in-one, universell, weitergebbar.

- First-Run-Wizard: startet automatisch bei neuer Installation (Keys,
  Verarbeitung, erkannte Hardware); /setup + /setup/complete
- Data-Mounts via UI: Einstellungen -> Speicherziele haengt NFS/SMB direkt
  ein (mounts.py, CAP_SYS_ADMIN + rshared-Propagation, Auto-Remount beim
  Start, CIFS-Creds via Datei statt Kommandozeile); nfs-common/cifs-utils
  im api-Image
- Encoder-Erkennung: jeder Worker meldet beim Start ehrlich seine
  Faehigkeiten (caps.py -> workers-Tabelle), GET /capabilities, Anzeige
  in Wizard + Verarbeitung-Tab
- Task-Split: transcode_files als eigener Task auf Queue "transcode"
  (Basis fuer optionale Remote-GPU-Worker, deploy/remote-transcode-worker.yml
  EXPERIMENTELL) + POST /jobs/{id}/retry-transcode + UI-Knopf
  "Neu komprimieren" bei fehlgeschlagenen Jobs
- API-Keys aus der DB: Settings-UI/Wizard ueberstimmen Env — vorher waren
  die Key-Felder im UI reine Dekoration (Clients lasen nur Env)
- README komplett neu: generischer Schnellstart, Laufwerk-Override via
  docker-compose.override.yml, Architektur, Env-Tabelle

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

docker/api/main.py

@@ -12,7 +12,8 @@ import uuid
 
 import db
 import devices as device_discovery
-from celery_client import start_rip
+import mounts as mount_verwaltung
+from celery_client import celery_client, start_rip
 from detection import CDS_DISC_OK, CDS_NO_DISC, CDS_TRAY_OPEN, drive_status
 
 from fastapi.security import OAuth2PasswordBearer
@@ -60,6 +61,12 @@ async def startup_event():
     except ConfigValidationError as e:
         print(f"⚠️  Konfigurations-Warnung: {e}")
 
+    # Gespeicherte Netzwerk-Speicherziele wiederherstellen
+    def remount():
+        for meldung in mount_verwaltung.alle_remounten():
+            db.add_log("info", "mounts", meldung)
+    await asyncio.to_thread(remount)
+
     asyncio.create_task(disc_watcher())
 
 
@@ -316,6 +323,125 @@ async def eject_device(name: str):
     return {"status": "ejected", "device": device_path}
 
 
+@app.post("/jobs/{job_id}/retry-transcode")
+async def retry_transcode(job_id: str):
+    """Stößt die Kompression eines Jobs neu an — OHNE die Disc neu zu rippen.
+
+    Voraussetzung: die Rohdateien liegen noch in /app/temp/raw/<job_id>
+    (bei Kompressions-Fehlschlägen bleiben sie dort absichtlich erhalten).
+    """
+    job = await asyncio.to_thread(db.get_job, job_id)
+    if not job:
+        raise HTTPException(status_code=404, detail="Job nicht gefunden")
+    if job["status"] in ("running", "pending"):
+        raise HTTPException(status_code=409, detail="Job rippt noch")
+
+    raw_dir = f"/app/temp/raw/{job_id}"
+    basis = job.get("target_dir") or f"{MEDIA_ROOT}/{job.get('disc_type') or 'bluray'}"
+    final_dir = f"{basis}/{job_id}"
+
+    celery_client.send_task(
+        "worker.tasks.transcode_files",
+        args=[job_id, raw_dir, final_dir],
+        queue="transcode",
+    )
+    await asyncio.to_thread(db.update_job, job_id, status="transcoding", progress=0, error=None)
+    await asyncio.to_thread(db.add_log, "info", "api", f"Job {job_id}: Kompression neu eingereiht")
+    return {"id": job_id, "status": "transcoding"}
+
+
+@app.get("/capabilities")
+async def capabilities():
+    """Welche Encoder sind auf welchen Workern WIRKLICH verfügbar?
+
+    Jeder Worker meldet sich beim Start selbst (caps.py) — auch optionale
+    Remote-GPU-Worker tauchen hier automatisch auf.
+    """
+    return {"workers": await asyncio.to_thread(db.list_workers)}
+
+
+class MountRequest(BaseModel):
+    name: str
+    type: str          # nfs | cifs
+    source: str        # host:/export bzw. //host/share
+    options: Optional[str] = None
+    username: Optional[str] = None
+    password: Optional[str] = None
+
+
+@app.get("/storage-mounts")
+async def get_storage_mounts():
+    """Konfigurierte Netzwerk-Speicherziele inkl. Live-Mount-Status."""
+    eintraege = await asyncio.to_thread(db.list_mounts)
+    return [
+        {
+            "name": e["name"],
+            "type": e["typ"],
+            "source": e["quelle"],
+            "mounted": mount_verwaltung.ist_gemountet(e["name"]),
+            "has_credentials": bool(e.get("username")),
+        }
+        for e in eintraege
+    ]
+
+
+@app.post("/storage-mounts", status_code=201)
+async def create_storage_mount(request: MountRequest):
+    """Hängt ein NFS/SMB-Ziel ein und speichert es für den nächsten Start."""
+    if not mount_verwaltung.validiere_name(request.name):
+        raise HTTPException(status_code=422, detail="Name: nur a-z, 0-9, Bindestrich (2-31 Zeichen)")
+    if request.type not in ("nfs", "cifs"):
+        raise HTTPException(status_code=422, detail="Typ muss nfs oder cifs sein")
+    if any(e["name"] == request.name for e in await asyncio.to_thread(db.list_mounts)):
+        raise HTTPException(status_code=409, detail="Name bereits vergeben")
+
+    try:
+        await asyncio.to_thread(
+            mount_verwaltung.mounten,
+            request.name, request.type, request.source,
+            request.options or "", request.username or "", request.password or "",
+        )
+    except RuntimeError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+    await asyncio.to_thread(
+        db.save_mount,
+        request.name, request.type, request.source,
+        request.options or "", request.username or "", request.password or "",
+    )
+    await asyncio.to_thread(
+        db.add_log, "success", "mounts",
+        f"Speicherziel '{request.name}' ({request.type}) eingehängt: {request.source}",
+    )
+    return {"name": request.name, "mounted": True}
+
+
+@app.delete("/storage-mounts/{name}")
+async def delete_storage_mount(name: str):
+    """Hängt ein Netzwerk-Speicherziel aus und entfernt es aus der Konfiguration."""
+    try:
+        await asyncio.to_thread(mount_verwaltung.aushaengen, name)
+    except RuntimeError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    await asyncio.to_thread(db.delete_mount, name)
+    await asyncio.to_thread(db.add_log, "info", "mounts", f"Speicherziel '{name}' entfernt")
+    return {"status": "removed"}
+
+
+@app.get("/setup")
+async def setup_status():
+    """First-Run-Erkennung: wurde der Einrichtungs-Assistent abgeschlossen?"""
+    einstellungen = await asyncio.to_thread(db.get_settings, "setup")
+    return {"done": bool(einstellungen.get("done"))}
+
+
+@app.post("/setup/complete")
+async def setup_complete():
+    await asyncio.to_thread(db.save_settings, {"done": True}, "setup")
+    await asyncio.to_thread(db.add_log, "success", "setup", "Einrichtungs-Assistent abgeschlossen")
+    return {"done": True}
+
+
 @app.get("/logs")
 async def get_logs(limit: int = 200):
     """Echte Ereignisse aus der Datenbank (Watcher, API, Worker)."""