Praxis-Feedback-Runde: CIFS-Cap-Fix, TMDB v3-Keys, 4K-UHD-Typ, Vollautomatik, Job-Verwaltung, Worker-Namen

Zwei bewiesene Bug-Fixes:
- SMB-Mount 'Unable to apply new capability set': mount.cifs hebt
  CAP_DAC_READ_SEARCH an, die in Dockers Default-Caps fehlt (auf der VM
  reproduziert: Bounding-Set a82425fb ohne Bit 2; mit der Capability
  verschwindet der Fehler). Fix: cap_add DAC_READ_SEARCH fuer den
  api-Container.
- TMDB fiel still aus: Client konnte nur v4-Bearer-Tokens, der uebliche
  32-Hex-v3-Key bekam 401 und die Suche lieferte nur OMDb. Jetzt beide
  Key-Arten (ist_v4_token + api_key-Query-Param lt.
  developer.themoviedb.org, mit Tests) — damit kommen auch die deutschen
  Texte an (language=de-DE war ueberall schon gesetzt). Neu:
  GET /metadata/status + 'Verbindung pruefen' in Einstellungen -> APIs
  (Live-Check am Cache vorbei).

Features aus dem Commander-Feedback:
- 4K UHD als eigener Disc-Typ: classify >= 55 GiB (BD-66/BD-100; BD-50
  bleibt bluray), beide detection.py + Tests, eigene Badge-Farbe in
  Dashboard/Laufwerken, Prescan-Label '4K UHD'. UHD-Rip-Fehler 'Failed to
  open disc' (Code 11) bekommt Klartext: LibreDrive-Firmware noetig.
- Vollautomatik (Setting autoRipStart): Disc erkannt -> Rip startet ohne
  Popup in den Schnellwahl-Ordner (Serie->Serien, sonst Filme, CD->Musik).
- Job-Verwaltung: 'Neu komprimieren' nur noch mit can_retry (Rohdaten
  liegen wirklich da), DELETE /jobs/{id} + 'Erledigte aufraeumen'
  (Dateien bleiben immer), 'Alle herunterladen' im Job-Detail
  (gestaffelte Einzel-Downloads statt Server-Zip von 40-GB-Dateien).
- Worker zuordenbar: WORKER_NAME-Env als stabiler Anzeigename (fixt auch
  die Offline-Leichen nach Rebuilds), info.hostname/ip gemeldet,
  Online-Abgleich ueber hostname, DELETE /workers/{name} + Papierkorb im
  UI, Quelle-Anzeige an der Disc-Karte ('Quelle: TMDB - 99 % sicher').
- Ripping-Tab nach Medium gegliedert (Video/Audio-CD/Allgemein) +
  Untertitel-Klartext (--all-audio/--all-subtitles bleiben komplett),
  CD -> Musik-Vorauswahl im Ziel-Dialog, Ordner-Verwaltung beschriftet
  und standardmaessig eingeklappt.
- Docs: SAVEPOINT v3.3, ROADMAP Etappe 14 + Ideen (nativer
  Windows-Worker, deutsche OMDb-Texte via TMDB-Find), README.

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

docker/api/clients/tmdb.py

@@ -11,6 +11,15 @@ TMDB_BASE_URL = "https://api.themoviedb.org/3"
 TMDB_IMAGE_BASE_URL = "https://image.tmdb.org/t/p"
 
 
+def ist_v4_token(key: str) -> bool:
+    """Pure Funktion (testbar): TMDB hat ZWEI Key-Arten — der v4 Read Access
+    Token ist ein langes JWT ('eyJ…', Bearer-Header), der klassische v3-Key
+    32 Hex-Zeichen (api_key-Query-Parameter). Befund 24.07.: der Client konnte
+    NUR v4 — mit dem üblichen v3-Key aus dem TMDB-Konto war jede Anfrage 401
+    und die Suche lieferte still nur OMDb-Treffer."""
+    return bool(key) and key.startswith("eyJ")
+
+
 class TMDBClient:
     def __init__(self):
         # DB-Einstellung (Settings-UI/Wizard) gewinnt gegen die Env-Variable —
@@ -18,24 +27,29 @@ class TMDBClient:
         from db import get_settings
         self.api_key = get_settings().get("tmdbApiKey") or settings.tmdb_api_key
         self.session = requests.Session()
-        self.session.headers.update({
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json"
-        })
-    
+        self.session.headers.update({"Content-Type": "application/json"})
+        # Beide Key-Arten unterstützen (developer.themoviedb.org: v3 als
+        # api_key-Parameter, v4-Token als Bearer-Header)
+        self._key_params = {}
+        if ist_v4_token(self.api_key):
+            self.session.headers.update({"Authorization": f"Bearer {self.api_key}"})
+        elif self.api_key:
+            self._key_params = {"api_key": self.api_key}
+
     def _request(self, endpoint: str, params: Dict = None) -> Optional[Dict]:
         """Mache API-Request mit Caching."""
         from cache.keys import generate_tmdb_key
+        # Cache-Key OHNE den api_key — der gehört nicht in den Cache
         cache_key = generate_tmdb_key(endpoint, params)
-        
+
         cached = get(cache_key)
         if cached:
             return cached
-        
+
         try:
             response = self.session.get(
                 f"{TMDB_BASE_URL}/{endpoint}",
-                params=params,
+                params={**(params or {}), **self._key_params},
                 timeout=10
             )
             response.raise_for_status()

docker/api/db.py

@@ -189,6 +189,27 @@ def list_jobs(limit: int = 100) -> list:
     return [dict(z) for z in zeilen]
 
 
+def delete_job(job_id: str) -> None:
+    """Entfernt EINEN Job-Eintrag (nur die DB-Zeile — Dateien bleiben)."""
+    with engine.begin() as conn:
+        conn.execute(jobs.delete().where(jobs.c.id == job_id))
+
+
+def delete_finished_jobs() -> int:
+    """Räumt alle erledigten Jobs (completed/failed) aus der Liste. Dateien bleiben."""
+    with engine.begin() as conn:
+        ergebnis = conn.execute(
+            jobs.delete().where(jobs.c.status.in_(("completed", "failed")))
+        )
+    return ergebnis.rowcount or 0
+
+
+def delete_worker(name: str) -> None:
+    """Entfernt einen (verwaisten) Worker-Eintrag aus der Liste."""
+    with engine.begin() as conn:
+        conn.execute(workers.delete().where(workers.c.name == name))
+
+
 def has_active_job(device: str) -> bool:
     """True, wenn auf dem Gerät ein Job läuft oder wartet (Eject-Schutz)."""
     with engine.connect() as conn:

docker/api/detection.py

@@ -36,6 +36,10 @@ BLKGETSIZE64 = 0x80081272
 # Eine DVD9 fasst ~8,5 GB; Blu-ray beginnt bei 25 GB (Single Layer).
 # Alles ab 10 GB ist also sicher eine Blu-ray.
 BLURAY_MIN_BYTES = 10 * 1024**3
+# 4K-UHD-Discs sind BD-66 (66 GB) oder BD-100 — eine normale BD-50 bleibt
+# unter ~47 GiB. Ab 55 GiB ist es also sicher eine UHD. (Seltene 50-GB-UHDs
+# laufen als "bluray" — der Rip-Weg ist ohnehin identisch.)
+UHD_MIN_BYTES = 55 * 1024**3
 
 
 def _open_nonblock(device_path: str) -> int:
@@ -73,10 +77,12 @@ def disc_size_bytes(device_path: str) -> int:
 
 
 def classify(disc_status_code: int, size_bytes: int) -> str:
-    """Pure Zuordnung (testbar): Disc-Status + Größe → cd | dvd | bluray | unknown."""
+    """Pure Zuordnung (testbar): Disc-Status + Größe → cd | dvd | bluray | uhd | unknown."""
     if disc_status_code in (CDS_AUDIO, CDS_MIXED):
         return "cd"
     if disc_status_code in (CDS_DATA_1, CDS_DATA_2, CDS_XA_2_1, CDS_XA_2_2):
+        if size_bytes >= UHD_MIN_BYTES:
+            return "uhd"
         return "bluray" if size_bytes >= BLURAY_MIN_BYTES else "dvd"
     return "unknown"
 

docker/api/main.py

@@ -91,11 +91,56 @@ async def _auto_prescan(pfad: str):
             + (f" ({ergebnis.year})" if ergebnis.year else "")
             + f" [{ergebnis.disc_type}, Confidence {ergebnis.confidence:.0%}] auf {pfad}",
         )
+        await _auto_rip_wenn_aktiviert(pfad)
     except Exception as e:
         DISC_CACHE.pop(pfad, None)
         print(f"Auto-Pre-Scan {pfad}: {e}")
 
 
+async def _auto_rip_wenn_aktiviert(pfad: str):
+    """Vollautomatik (Setting autoRipStart): Disc erkannt → Rip startet sofort.
+
+    Commander-Wunsch 24.07.: wahlweise Popup ODER Automatik. Ziel-Ordner
+    kommt aus den Schnellwahl-Einstellungen (Serie → seriesDir, sonst
+    movieDir; CD → musicDir) — genau wie ein Klick im Dialog.
+    """
+    einstellungen = await asyncio.to_thread(db.get_settings)
+    if not einstellungen.get("autoRipStart"):
+        return
+    if await asyncio.to_thread(db.has_active_job, pfad):
+        return
+    disc = DISC_CACHE.get(pfad) or {}
+    if disc.get("_laeuft"):
+        return
+
+    basis = einstellungen.get("outputDir") or MEDIA_ROOT
+    meta = disc.get("metadata") or {}
+    if disc.get("disc_type") == "CD":
+        unterordner = einstellungen.get("musicDir") or "music"
+    elif meta.get("type") == "tv":
+        unterordner = einstellungen.get("seriesDir") or "series"
+    else:
+        unterordner = einstellungen.get("movieDir") or "movies"
+    ziel = os.path.normpath(os.path.join(basis, unterordner))
+    if not ziel.startswith(MEDIA_ROOT):
+        ziel = None
+
+    job_id = str(uuid.uuid4())
+    meta_json = json.dumps({
+        "year": disc.get("year"),
+        "confidence": disc.get("confidence"),
+        **meta,
+    })
+    await asyncio.to_thread(
+        db.insert_job, job_id, pfad, None, disc.get("title"), ziel, meta_json
+    )
+    await asyncio.to_thread(
+        db.add_log, "info", "api",
+        f'Automatik: Rip für „{disc.get("title")}" gestartet ({pfad} → {ziel})',
+    )
+    start_rip(pfad, job_id, ziel)
+
+
 async def disc_watcher():
     """Disc-Wache: pollt die Laufwerke, protokolliert Einwurf/Auswurf und
     stößt beim Einlegen automatisch den Pre-Scan an (Dashboard-Disc-Karte).
@@ -178,6 +223,7 @@ class Job(BaseModel):
     progress: int = 0
     title: Optional[str] = None
     error: Optional[str] = None
+    can_retry: bool = False  # Rohdaten vorhanden → „Neu komprimieren" sinnvoll
 
 class Device(BaseModel):
     id: str
@@ -219,11 +265,52 @@ async def root():
     }
 
 
+def _kann_neu_komprimieren(job: dict, work_dir: str) -> bool:
+    """Nur wenn Rohdaten wirklich noch daliegen — der „Neu komprimieren"-Knopf
+    an einem Job, der nie gerippt hat, war Unsinn (Befund 24.07.)."""
+    if job.get("status") != "failed":
+        return False
+    if os.path.isdir(os.path.join("/app/temp/raw", job["id"])):
+        return True
+    return work_dir.startswith(MEDIA_ROOT) and os.path.isdir(os.path.join(work_dir, job["id"]))
+
+
 @app.get("/jobs", response_model=List[Job])
 async def get_jobs():
     """Holt alle Jobs aus der Datenbank (neueste zuerst)."""
-    zeilen = await asyncio.to_thread(db.list_jobs)
-    return [_job_row_to_model(z) for z in zeilen]
+    def sammle():
+        work_dir = os.path.normpath((db.get_settings().get("workDir") or "").strip() or "/")
+        modelle = []
+        for z in db.list_jobs():
+            modell = _job_row_to_model(z)
+            modell.can_retry = _kann_neu_komprimieren(z, work_dir)
+            modelle.append(modell)
+        return modelle
+
+    return await asyncio.to_thread(sammle)
+
+
+@app.delete("/jobs/{job_id}")
+async def delete_job(job_id: str):
+    """Entfernt einen erledigten Job aus der Liste (Dateien bleiben liegen)."""
+    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"] not in ("completed", "failed"):
+        raise HTTPException(status_code=409, detail="Job läuft noch — erst abbrechen")
+    await asyncio.to_thread(db.delete_job, job_id)
+    await asyncio.to_thread(db.add_log, "info", "api", f"Job {job_id} aus der Liste entfernt")
+    return {"status": "deleted"}
+
+
+@app.delete("/jobs")
+async def delete_finished_jobs():
+    """Räumt ALLE erledigten Jobs (fertig + fehlgeschlagen) aus der Liste."""
+    anzahl = await asyncio.to_thread(db.delete_finished_jobs)
+    await asyncio.to_thread(
+        db.add_log, "info", "api", f"Job-Liste aufgeräumt ({anzahl} erledigte Einträge entfernt)"
+    )
+    return {"deleted": anzahl}
 
 
 class JobCreateRequest(BaseModel):
@@ -500,12 +587,67 @@ async def capabilities():
         except Exception:
             online_namen = set()
         for zeile in zeilen:
-            zeile["online"] = zeile["name"] in online_namen
+            # Celery-Ping meldet den HOSTNAME des Knotens — bei gesetztem
+            # WORKER_NAME (Anzeigename) steckt der echte Hostname in info.
+            hostname = (zeile.get("info") or {}).get("hostname") or zeile["name"]
+            zeile["online"] = hostname in online_namen
         return zeilen
 
     return {"workers": await asyncio.to_thread(sammle)}
 
 
+@app.delete("/workers/{name}")
+async def delete_worker(name: str):
+    """Verwaisten Worker-Eintrag entfernen (alte Container-IDs nach Rebuilds).
+
+    Ein AKTIVER Worker meldet sich binnen einer Minute einfach wieder an —
+    löschen ist also immer gefahrlos."""
+    await asyncio.to_thread(db.delete_worker, name)
+    await asyncio.to_thread(db.add_log, "info", "api", f"Worker-Eintrag '{name}' entfernt")
+    return {"status": "deleted"}
+
+
+@app.get("/metadata/status")
+async def metadata_status():
+    """Live-Prüfung der Metadaten-Quellen — beantwortet „funktioniert mein
+    Key?" sofort statt durch stilles Wegfallen einer Quelle."""
+    def pruefe():
+        from clients.omdb import OMDB_BASE_URL
+        from clients.tmdb import TMDB_BASE_URL
+
+        status = {}
+        prescan = PreScan()
+        # Bewusst am Cache VORBEI — ein alter Treffer soll keinen kaputten
+        # Key als "ok" tarnen. /configuration ist der kleinste Auth-Aufruf.
+        if not prescan.tmdb.api_key:
+            status["tmdb"] = "kein_key"
+        else:
+            try:
+                antwort = prescan.tmdb.session.get(
+                    f"{TMDB_BASE_URL}/configuration",
+                    params=prescan.tmdb._key_params, timeout=10,
+                )
+                status["tmdb"] = "ok" if antwort.status_code == 200 else "fehler"
+            except Exception:
+                status["tmdb"] = "fehler"
+        if not prescan.omdb.api_key:
+            status["omdb"] = "kein_key"
+        else:
+            try:
+                antwort = prescan.omdb.session.get(
+                    OMDB_BASE_URL,
+                    params={"apikey": prescan.omdb.api_key, "t": "Inception"},
+                    timeout=10,
+                ).json()
+                status["omdb"] = "ok" if antwort.get("Response") == "True" else "fehler"
+            except Exception:
+                status["omdb"] = "fehler"
+        status["jikan"] = "ok"  # keyless — fällt nur bei Netzproblemen aus
+        return status
+
+    return await asyncio.to_thread(pruefe)
+
+
 class MountRequest(BaseModel):
     name: str
     type: str          # nfs | cifs

docker/api/prescan/prescan.py

@@ -253,7 +253,7 @@ class PreScan:
         installiert, die Erkennung fiel still immer auf "DVD" zurück.
         """
         typ = detection.detect_disc_type(device_path)
-        return {"cd": "CD", "dvd": "DVD", "bluray": "Blu-ray"}.get(typ, "DVD")
+        return {"cd": "CD", "dvd": "DVD", "bluray": "Blu-ray", "uhd": "4K UHD"}.get(typ, "DVD")
 
     def _read_toc(self, device_path: str, disc_type: str) -> Dict:
         """Lese TOC (Table of Contents)."""
@@ -403,7 +403,8 @@ class PreScan:
                             "poster_path": movie_details.get("poster_path", ""),
                             "backdrop_path": movie_details.get("backdrop_path", ""),
                             "runtime": movie_details.get("runtime", 0),
-                            "genres": [g["name"] for g in movie_details.get("genres", [])]
+                            "genres": [g["name"] for g in movie_details.get("genres", [])],
+                            "source": "tmdb",
                         }
                         matched = True
                         break
@@ -426,7 +427,8 @@ class PreScan:
                                 "overview": tv_details.get("overview", ""),
                                 "poster_path": tv_details.get("poster_path", ""),
                                 "backdrop_path": tv_details.get("backdrop_path", ""),
-                                "genres": [g["name"] for g in tv_details.get("genres", [])]
+                                "genres": [g["name"] for g in tv_details.get("genres", [])],
+                                "source": "tmdb",
                             }
                             matched = True
                             break
@@ -471,7 +473,8 @@ class PreScan:
                     "poster_path": vorschlag.get("poster_path", ""),
                     "backdrop_path": vorschlag.get("backdrop_path", ""),
                     "runtime": vorschlag.get("runtime", 0),
-                    "genres": [g["name"] for g in vorschlag.get("genres", [])]
+                    "genres": [g["name"] for g in vorschlag.get("genres", [])],
+                    "source": "tmdb",
                 }
                 matched = True
 

docker/api/test_tmdb_helpers.py

@@ -0,0 +1,20 @@
+"""Tests für die TMDB-Key-Erkennung (v3-Schlüssel vs. v4-Token).
+
+Befund 24.07.: Der Client konnte nur v4-Bearer — mit dem üblichen 32-Hex-
+v3-Key war jede Anfrage 401 und TMDB fiel still aus (nur OMDb-Treffer).
+"""
+
+from clients.tmdb import ist_v4_token
+
+
+def test_v4_token_wird_erkannt():
+    assert ist_v4_token("eyJhbGciOiJIUzI1NiJ9.irgendwas.signatur") is True
+
+
+def test_v3_hex_key_ist_kein_v4_token():
+    assert ist_v4_token("842abc0123456789842abc0123456789") is False
+
+
+def test_leer_ist_kein_token():
+    assert ist_v4_token("") is False
+    assert ist_v4_token(None) is False