Restefeger: Auth komplett raus, Serien-Flow + Episoden-Matching, Jellyfin-Refresh, Duplikat-Warnung, echtes Nur-Hauptfilm

AUTH ENTFERNT (Commander-Entscheid 24.07., KONZEPT §10): /token- und
/api-keys-Endpoints, auth.py, test_auth.py, passlib/bcrypt/PyJWT/
python-multipart, JWT_SECRET_KEY-Pflicht. Heimnetz-only, das UI hatte nie
einen Login — die Auth-Oberflaeche war Placebo und die passlib/bcrypt-
Falle brach die Ampel. Rate-Limit pro IP bleibt. Schnellstart laeuft
jetzt ganz ohne .env-Pflichtwerte.

Serien-Flow (Etappe-12-Kern, ARM-Wunde #395):
- Rip-Dialog: Serienname + Staffel -> Ablage <Serie>/Season NN
  (jellyfin.org/docs Naming-Schema); tvshow.nfo + poster.jpg im
  Serien-Ordner, bei Staffel 2 nicht ueberschrieben.
- Episoden-Matching per Laufzeitabgleich: HandBrakeCLI --scan
  ('+ duration:', handbrake.fr/docs) je MKV gegen TMDB-Staffel-Laufzeiten
  (GET /metadata/tv/{id}/season/{n}; tv-season-details-API).
  Ordnungserhaltend; komplette Staffel auf einer Disc klappt auch bei
  uniformen Anime-Laufzeiten (Sequenz-Stufe). Umbenannt wird NUR bei
  eindeutiger Zuordnung — sonst ehrliches Log. Mit Tests.

Weitere Punkte:
- Jellyfin/Emby-Bibliotheks-Refresh nach jedem fertigen Rip
  (POST /Library/Refresh, X-Emby-Token lt. jellyfin.org/docs) —
  URL/Key + Test-Knopf in Einstellungen -> Ripping.
- Duplikat-Warnung: Disc-Fingerabdruck (jetzt Teil des Prescan-Ergebnisses
  + der Job-Metadaten) gegen die Historie; Karte zeigt 'bereits gerippt',
  Vollautomatik ueberspringt Duplikate.
- 'Nur Hauptfilm' ECHT: makemkvcon info -> TINFO-Attr-9-Laufzeiten
  (usage.txt) -> laengster Titel -> mkv dev:X <nr>. Vorher wirkungsloses
  Setting; pro Rip im Dialog uebersteuerbar. Mit Tests.
- OMDb-Treffer eingedeutscht via TMDB /find (external_source=imdb_id,
  de-DE; find-by-id-API).
- Dashboard: Speicherplatz-Anzeige (amber < 60 GB) + CSV-Export
  (GET /jobs/export, Semikolon+BOM fuer deutsches Excel).
- Metadaten-Seite entfernt (Abnahme durch Commander-Auftrag) inkl.
  Placebo-Endpoints /metadata/lookup (scannte Dummy-Device) und
  /metadata/confirm (schrieb nie gelesenen Cache-Key).
- Doppel-Jahr-Fix: 'X (2009) (2009)' in Log und Ordnernamen.
- Remote-Worker-Blocker: redis (6379) + postgres (5432) waren NIE
  veroeffentlicht — kein Remote-Worker konnte sich je verbinden. Ports
  jetzt offen (Heimnetz-Kompromiss, kommentiert) + API_URL fuer Worker.

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

docker/worker/tasks.py

@@ -17,6 +17,8 @@ import json
 import os
 import shutil
 
+import requests
+
 import db
 import medien
 import notify
@@ -26,11 +28,14 @@ from ripping import (
     DEFAULT_HB_PRESET,
     RIP_OUTPUT_DIR,
     RipAbbruch,
+    lies_datei_dauer,
     rip_cd,
     rip_video,
     run_handbrake,
 )
 
+API_URL = os.getenv("API_URL", "http://api:8000")
+
 RAW_DIR = os.getenv("RAW_DIR", "/app/temp/raw")
 MEDIA_ROOT = "/app/media"
 
@@ -111,6 +116,47 @@ def _abbruch_angefordert(job_id: str) -> bool:
     return db.get_job_status(job_id) == "canceling"
 
 
+def _serien_episoden_zuordnen(ausgabe: str, serie: str, staffel, meta: dict) -> list:
+    """Episoden-Zuordnung per Laufzeitabgleich (ARM-Wunde #395, besser gelöst).
+
+    Laufzeiten der Staffel kommen von der API (TMDB); die der Dateien vom
+    HandBrake-Scan. Nur bei EINDEUTIGEM Treffer wird umbenannt. Wirft nie.
+    """
+    if meta.get("source") != "tmdb" or meta.get("type") != "tv" or not meta.get("id"):
+        return ["Episoden-Zuordnung übersprungen (nur mit TMDB-Serien-Treffer möglich)"]
+    try:
+        antwort = requests.get(
+            f"{API_URL}/metadata/tv/{meta['id']}/season/{int(staffel)}", timeout=30
+        )
+        if antwort.status_code != 200:
+            return [f"Episoden-Laufzeiten nicht abrufbar (HTTP {antwort.status_code})"]
+        episoden = [
+            (e["episode"], (e.get("runtime") or 0) * 60)
+            for e in antwort.json().get("episodes", [])
+        ]
+    except (requests.RequestException, ValueError) as e:
+        return [f"Episoden-Laufzeiten nicht abrufbar: {e}"]
+    if not episoden:
+        return ["Keine Episoden-Laufzeiten bei TMDB hinterlegt — Dateinamen bleiben"]
+
+    dateien = sorted(
+        os.path.join(ausgabe, f) for f in os.listdir(ausgabe) if f.endswith(".mkv")
+    )
+    if not dateien:
+        return []
+    dauern = [lies_datei_dauer(p) for p in dateien]
+    if 0 in dauern:
+        return ["Datei-Laufzeiten nicht lesbar — Dateinamen bleiben"]
+
+    zuordnung = medien.matche_episoden(dauern, episoden)
+    if not zuordnung:
+        return [
+            "Keine EINDEUTIGE Episoden-Zuordnung über die Laufzeiten — "
+            "Dateinamen bleiben (lieber ehrlich als falsch benannt)"
+        ]
+    return medien.episoden_umbenennen(ausgabe, serie, staffel, zuordnung)
+
+
 def _benachrichtigen(job_id: str, betreff: str, text: str, level: str) -> None:
     """Webhook-Meldung bei Job-Ende — best effort, nie job-entscheidend."""
     einstellungen = db.get_settings()
@@ -143,17 +189,38 @@ def _job_abschliessen(job_id: str, ergebnis: dict) -> None:
     if ergebnis.get("status") == "success":
         ausgabe = ergebnis.get("output_dir")
         if ausgabe and (job.get("disc_type") in ("dvd", "bluray", "uhd")):
-            # Media-Server-Aufbereitung (Jellyfin/Emby/Kodi: NFO + Poster)
             einstellungen = db.get_settings()
             try:
                 meta = json.loads(job.get("meta") or "{}")
             except ValueError:
                 meta = {}
+            serie = meta.get("series")
+            staffel = meta.get("season")
+
+            # Serien-Rips: Episoden per Laufzeit zuordnen und umbenennen
+            # (Show S01E02.mkv) — nur bei EINDEUTIGER Zuordnung, sonst
+            # bleiben die MakeMKV-Namen (ehrlich geloggt).
+            if serie and staffel:
+                for meldung in _serien_episoden_zuordnen(ausgabe, serie, staffel, meta):
+                    db.add_log("info", "worker", f"Job {job_id}: {meldung}")
+
+            # Media-Server-Aufbereitung (Jellyfin/Emby/Kodi: NFO + Poster);
+            # bei Serien wandern tvshow.nfo/poster in den Serien-Ordner.
             for meldung in medien.aufbereiten(
                 ausgabe, einstellungen.get("mediaServer") or "none",
-                job.get("title") or "", meta.get("year"), meta,
+                serie or job.get("title") or "", meta.get("year"), meta,
+                serien_root=os.path.dirname(ausgabe) if serie and staffel else None,
             ):
                 db.add_log("info", "worker", f"Job {job_id}: {meldung}")
+
+            # Bibliotheks-Refresh (Jellyfin/Emby): der Server scannt sofort
+            meldung = medien.bibliothek_refresh(
+                einstellungen.get("mediaServer") or "none",
+                (einstellungen.get("jellyfinUrl") or "").strip(),
+                (einstellungen.get("jellyfinApiKey") or "").strip(),
+            )
+            if meldung:
+                db.add_log("info", "worker", f"Job {job_id}: {meldung}")
         db.update_job(
             job_id,
             status="completed",
@@ -228,15 +295,29 @@ def rip_disc(self, device_path: str, job_id: str, target_dir: str = None):
 
     # Sprechender Zielordner „<Titel> (Jahr)" statt Job-UUID — Jellyfin & Co.
     # erkennen den Film am Ordnernamen. UUID bleibt Fallback ohne Titel.
+    # Serien-Rips landen stattdessen in <Serie>/Season NN (Staffel-Flow).
     job = db.get_job(job_id) or {}
     try:
         meta = json.loads(job.get("meta") or "{}")
     except ValueError:
         meta = {}
-    final_dir = medien.zielordner(
-        _zielbasis(target_dir, disc_type),
-        job.get("title") or "", meta.get("year"), job_id,
-    )
+    if meta.get("series") and meta.get("season"):
+        final_dir = medien.serien_ordner(
+            _zielbasis(target_dir, disc_type), meta["series"], meta["season"]
+        )
+    else:
+        final_dir = medien.zielordner(
+            _zielbasis(target_dir, disc_type),
+            job.get("title") or "", meta.get("year"), job_id,
+        )
+
+    # Nur Hauptfilm (längster Titel): pro Rip wählbar, sonst Setting;
+    # bei Serien-Discs sinnlos (dort zählen ALLE Episoden-Titel).
+    nur_hauptfilm = meta.get("main_feature_only")
+    if nur_hauptfilm is None:
+        nur_hauptfilm = bool(einstellungen.get("mainFeatureOnly", False))
+    if meta.get("series"):
+        nur_hauptfilm = False
     # Geplantes Ziel sofort sichtbar machen (UI-Detail + retry-transcode)
     db.update_job(job_id, output_path=final_dir)
 
@@ -267,11 +348,13 @@ def rip_disc(self, device_path: str, job_id: str, target_dir: str = None):
             device_path, job_id, disc_type,
             progress_cb=fortschritt,
             output_dir=raw_dir,
+            nur_hauptfilm=nur_hauptfilm,
         )
     else:
         ergebnis = rip_video(
             device_path, job_id, disc_type,
             progress_cb=fortschritt, output_dir=final_dir,
+            nur_hauptfilm=nur_hauptfilm,
         )
 
     # UHD-Fehler in Klartext übersetzen — "Failed to open disc" allein hilft