feat(backend): Media-Server-Aufbereitung, echte Webhooks, SMB-Klartext, UHD-Arbeitsverzeichnis, MakeMKV-Key via UI

- jobs.meta (Migration in beiden db.py): Disc-Metadaten wandern in den Job —
  Quelle fuer Job-Detail-Popup (GET /jobs/{id}/detail), Ordner-Benennung, NFO.
- medien.py (Worker, mit Tests): Zielordner 'Titel (Jahr)' statt Job-UUID;
  movie.nfo/tvshow.nfo (Kodi-Schema, kodi.wiki/view/NFO_files) + poster.jpg
  fuer jellyfin/emby/kodi; plex nur Benennung; Kollision -> Job-ID-Suffix.
- notify.py (identisch in API+Worker, mit Tests): Webhook bei Job-Ende —
  Discord ({content}, discord.com/developers), Slack ({text},
  api.slack.com/messaging/webhooks), ntfy (Rohtext + ?title=, docs.ntfy.sh),
  generisches JSON. Vorher war das Setting ein Placebo: nichts sendete je.
  POST /notifications/test beweist die Anbindung sofort.
- mounts.py: NT_STATUS-Fehler -> handelbarer Klartext (ACCESS_DENIED ohne
  Credentials = Gast-Abfrage verweigert), Timeout-Meldung, mount-Hinweis
  bei error(13). Mit Tests.
- tasks.py: Platz-Check per Disc-Groesse (ioctl BLKGETSIZE64) VOR dem Rip;
  Arbeitsverzeichnis workDir (unter /app/media, z.B. NAS) statt fix
  /app/temp/raw — 4K-UHD-Rohdaten (bis 100 GB) sprengen sonst die VM-Platte;
  MakeMKV-Key aus UI-Settings (~/.MakeMKV/settings.conf, Format wie
  entrypoint.sh) gilt ab dem naechsten Rip ohne Rebuild.
- caps.py: Werkzeug-Versionen (MakeMKV aus ENV MAKEMKV_VERSION im Image,
  makemkvcon hat keinen --version-Schalter lt. usage.txt; HandBrakeCLI
  --version lt. handbrake.fr/docs) + Key-Quelle; workers.info-Spalte.
- /browse liefert jetzt auch DATEIEN (Name + Groesse) — der 'leere'
  bluray-Ordner war voll, der Browser zeigte nur Unterordner.
- GET /system/info: Versionen, Plattenplatz, Key-/Webhook-Status.

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

docker/worker/Dockerfile

@@ -76,6 +76,11 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 COPY --from=makemkv-build /usr/local /usr/local
 RUN ldconfig
 
+# Version fürs UI sichtbar machen (Einstellungen → System): makemkvcon hat
+# keinen --version-Schalter, also kommt die Wahrheit aus dem Build selbst.
+ARG MAKEMKV_VERSION=1.17.7
+ENV MAKEMKV_VERSION=${MAKEMKV_VERSION}
+
 WORKDIR /app
 
 COPY docker/worker/requirements.txt .

docker/worker/caps.py

@@ -6,7 +6,9 @@ Remote-GPU-Worker meldet sich hier genauso wie der eingebaute CPU-Worker.
 """
 
 import os
+import re
 import shutil
+import subprocess
 
 
 def erkenne_encoder() -> list:
@@ -22,3 +24,39 @@ def erkenne_encoder() -> list:
         gefunden.append("nvenc")
 
     return gefunden
+
+
+def werkzeug_versionen() -> dict:
+    """Kern-Werkzeuge dieses Workers — fürs UI (Einstellungen → System).
+
+    MakeMKV-Version kommt aus dem Build (ENV MAKEMKV_VERSION im Dockerfile) —
+    makemkvcon hat keinen dokumentierten --version-Schalter (usage.txt).
+    HandBrakeCLI --version ist dokumentiert (handbrake.fr/docs, CLI Options)
+    und gibt z.B. "HandBrake 1.6.1" aus.
+    """
+    info = {}
+    if shutil.which("makemkvcon"):
+        info["makemkv"] = os.getenv("MAKEMKV_VERSION") or "installiert"
+    if shutil.which("HandBrakeCLI"):
+        try:
+            aus = subprocess.run(
+                ["HandBrakeCLI", "--version"],
+                capture_output=True, text=True, timeout=15,
+            )
+            treffer = re.search(r"HandBrake\s+([\w.]+)", (aus.stdout or "") + (aus.stderr or ""))
+            info["handbrake"] = treffer.group(1) if treffer else "installiert"
+        except (OSError, subprocess.TimeoutExpired):
+            info["handbrake"] = "installiert"
+    # Woher kommt der MakeMKV-Key? UI-Setting schlägt Env — ehrlich anzeigen.
+    try:
+        import db
+        ui_key = (db.get_settings().get("makemkvAppKey") or "").strip()
+    except Exception:
+        ui_key = ""
+    if ui_key:
+        info["makemkv_key"] = "ui"
+    elif os.getenv("MAKEMKV_APP_KEY"):
+        info["makemkv_key"] = "env"
+    else:
+        info["makemkv_key"] = "keiner"
+    return info

docker/worker/celery_app.py

@@ -43,7 +43,11 @@ def melde_faehigkeiten(**kwargs):
         while True:
             try:
                 db.init_db()
-                db.save_worker(socket.gethostname(), caps.erkenne_encoder())
+                db.save_worker(
+                    socket.gethostname(),
+                    caps.erkenne_encoder(),
+                    caps.werkzeug_versionen(),
+                )
             except Exception as e:  # DB weg → weiterversuchen, nicht sterben
                 print(f"Fähigkeiten-Meldung fehlgeschlagen: {e}")
             time.sleep(60)

docker/worker/db.py

@@ -36,7 +36,9 @@ jobs = Table(
     Column("status", String(16), nullable=False, server_default="pending"),
     Column("progress", Integer, nullable=False, server_default="0"),
     Column("output_path", Text),
+    Column("target_dir", String(255)),
     Column("error", Text),
+    Column("meta", Text),  # Disc-Metadaten (JSON) — Quelle für Ordnernamen + NFO
     Column("created_at", DateTime(timezone=True)),
     Column("finished_at", DateTime(timezone=True)),
 )
@@ -57,8 +59,22 @@ def utcnow() -> datetime:
 
 
 def init_db() -> None:
-    """Legt fehlende Tabellen an (idempotent)."""
+    """Legt fehlende Tabellen an (idempotent) und zieht Mini-Migrationen nach.
+
+    Die ALTERs stehen identisch in docker/api/db.py — wer zuerst startet,
+    migriert; der andere findet die Spalten dann bereits vor.
+    """
     metadata.create_all(engine)
+    with engine.begin() as conn:
+        conn.exec_driver_sql(
+            "ALTER TABLE jobs ADD COLUMN IF NOT EXISTS target_dir VARCHAR(255)"
+        )
+        conn.exec_driver_sql(
+            "ALTER TABLE jobs ADD COLUMN IF NOT EXISTS meta TEXT"
+        )
+        conn.exec_driver_sql(
+            "ALTER TABLE workers ADD COLUMN IF NOT EXISTS info TEXT"
+        )
 
 
 settings_table = Table(
@@ -73,15 +89,17 @@ workers = Table(
     metadata,
     Column("name", String(128), primary_key=True),
     Column("encoders", Text),
+    Column("info", Text),  # Werkzeug-Versionen (JSON: makemkv/handbrake/key-Quelle)
     Column("last_seen", DateTime(timezone=True)),
 )
 
 
-def save_worker(name: str, encoder_liste: list) -> None:
-    """Worker meldet Name + Encoder-Fähigkeiten (Upsert)."""
+def save_worker(name: str, encoder_liste: list, info: dict = None) -> None:
+    """Worker meldet Name + Encoder-Fähigkeiten + Werkzeug-Versionen (Upsert)."""
     import json
 
     payload = json.dumps(encoder_liste)
+    info_payload = json.dumps(info or {})
     with engine.begin() as conn:
         vorhanden = conn.execute(
             workers.select().where(workers.c.name == name)
@@ -89,12 +107,14 @@ def save_worker(name: str, encoder_liste: list) -> None:
         if vorhanden:
             conn.execute(
                 workers.update().where(workers.c.name == name).values(
-                    encoders=payload, last_seen=utcnow()
+                    encoders=payload, info=info_payload, last_seen=utcnow()
                 )
             )
         else:
             conn.execute(
-                workers.insert().values(name=name, encoders=payload, last_seen=utcnow())
+                workers.insert().values(
+                    name=name, encoders=payload, info=info_payload, last_seen=utcnow()
+                )
             )
 
 
@@ -116,6 +136,18 @@ def get_settings(key: str = "ui") -> dict:
     return {}
 
 
+def get_job(job_id: str) -> dict:
+    """Ganze Job-Zeile — der Worker braucht Titel + Metadaten für die
+    Ordner-Benennung und die Media-Server-Aufbereitung (NFO/Poster)."""
+    from sqlalchemy import select
+
+    with engine.connect() as conn:
+        zeile = conn.execute(
+            select(jobs).where(jobs.c.id == job_id)
+        ).mappings().first()
+    return dict(zeile) if zeile else None
+
+
 def get_job_status(job_id: str) -> str:
     """Nur der Status — der Worker prüft damit kooperative Abbruch-Anfragen."""
     from sqlalchemy import select

docker/worker/medien.py

@@ -0,0 +1,107 @@
+"""Media-Server-Aufbereitung: sprechende Ordnernamen + NFO + Poster.
+
+Commander-Wunsch 24.07.: Rippy soll sich auf das Zielsystem (Jellyfin, Plex,
+Emby, Kodi) vorbereiten. Das Setting `mediaServer` steuert:
+- ALLE Systeme: Zielordner heißt „<Titel> (Jahr)" statt Job-UUID — daran
+  erkennen Jellyfin & Co. den Film (Namensschema laut jellyfin.org/docs/
+  general/server/media/movies bzw. support.plex.tv „Naming and Organizing").
+- jellyfin / emby / kodi: zusätzlich movie.nfo bzw. tvshow.nfo (Kodi-Schema,
+  kodi.wiki/view/NFO_files) + poster.jpg — diese Server lesen NFO nativ.
+- plex: NUR Benennung (Plex liest NFO ohne Zusatz-Agent nicht).
+- none: Verhalten wie bisher (UUID-Ordner, keine Extras).
+"""
+
+import os
+import re
+from xml.sax.saxutils import escape
+
+import requests
+
+NFO_SERVER = ("jellyfin", "emby", "kodi")
+# Zeichen, die in Ordnernamen auf SMB/NTFS/ext4 Ärger machen
+_VERBOTEN = re.compile(r'[<>:"/\\|?*\x00-\x1f]')
+
+
+def sicherer_name(titel: str, jahr=None) -> str:
+    """Pure Funktion (testbar): Titel → Dateisystem-tauglicher Ordnername."""
+    name = _VERBOTEN.sub("", titel or "").strip().rstrip(".")
+    name = re.sub(r"\s+", " ", name)[:150].strip()
+    if not name:
+        return ""
+    if jahr:
+        name = f"{name} ({jahr})"
+    return name
+
+
+def zielordner(basis: str, titel: str, jahr, job_id: str) -> str:
+    """Zielordner unter `basis`: sprechender Name, UUID nur als Fallback.
+
+    Existiert der Ordner schon (Disc doppelt gerippt), wird die Job-ID
+    angehängt statt fremde Dateien zu überschreiben.
+    """
+    name = sicherer_name(titel, jahr)
+    if not name:
+        return os.path.join(basis, job_id)
+    pfad = os.path.join(basis, name)
+    if os.path.exists(pfad):
+        pfad = os.path.join(basis, f"{name} [{job_id[:8]}]")
+    return pfad
+
+
+def baue_nfo(meta: dict, titel: str, jahr=None) -> str:
+    """Pure Funktion (testbar): minimales movie.nfo/tvshow.nfo im Kodi-Schema."""
+    ist_serie = (meta.get("type") == "tv")
+    wurzel = "tvshow" if ist_serie else "movie"
+    zeilen = [
+        '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>',
+        f"<{wurzel}>",
+        f"  <title>{escape(titel or '')}</title>",
+    ]
+    if jahr:
+        zeilen.append(f"  <year>{escape(str(jahr))}</year>")
+    if meta.get("overview"):
+        zeilen.append(f"  <plot>{escape(meta['overview'])}</plot>")
+    for genre in meta.get("genres") or []:
+        zeilen.append(f"  <genre>{escape(str(genre))}</genre>")
+    if meta.get("runtime"):
+        zeilen.append(f"  <runtime>{escape(str(meta['runtime']))}</runtime>")
+    quelle = meta.get("source") or "Rippy"
+    zeilen.append(f"  <details>Source: {escape(quelle)}</details>")
+    zeilen.append(f"</{wurzel}>")
+    return "\n".join(zeilen) + "\n"
+
+
+def aufbereiten(ordner: str, media_server: str, titel: str, jahr, meta: dict) -> list:
+    """Schreibt NFO + Poster in den fertigen Ordner (best effort).
+
+    Rückgabe: Liste von Meldungen fürs Log. Wirft NIE — ein fehlendes Poster
+    darf einen gelungenen Rip nicht auf 'failed' drehen.
+    """
+    meldungen = []
+    if media_server not in NFO_SERVER:
+        return meldungen
+    meta = meta or {}
+
+    try:
+        ist_serie = (meta.get("type") == "tv")
+        nfo_name = "tvshow.nfo" if ist_serie else "movie.nfo"
+        with open(os.path.join(ordner, nfo_name), "w", encoding="utf-8") as f:
+            f.write(baue_nfo(meta, titel, jahr))
+        meldungen.append(f"{nfo_name} geschrieben")
+    except OSError as e:
+        meldungen.append(f"NFO fehlgeschlagen: {e}")
+
+    poster = meta.get("poster_path") or ""
+    if poster:
+        if not poster.startswith("http"):
+            poster = f"https://image.tmdb.org/t/p/w500{poster}"
+        try:
+            antwort = requests.get(poster, timeout=15)
+            if antwort.status_code == 200 and antwort.content:
+                with open(os.path.join(ordner, "poster.jpg"), "wb") as f:
+                    f.write(antwort.content)
+                meldungen.append("poster.jpg gespeichert")
+        except requests.RequestException as e:
+            meldungen.append(f"Poster fehlgeschlagen: {e}")
+
+    return meldungen

docker/worker/notify.py

@@ -0,0 +1,66 @@
+"""Webhook-Benachrichtigungen bei Job-Ende (Discord, Slack, ntfy, generisch).
+
+Bis 24.07. war das notificationWebhook-Setting ein Placebo: das UI speicherte
+die URL, aber NICHTS hat je gesendet. Jetzt meldet der Worker Job-Ende
+(fertig/fehlgeschlagen/abgebrochen) und die API bietet einen Test-Endpoint.
+
+Das Modul existiert bewusst identisch in API und Worker
+(docker/api/notify.py) — es gibt kein geteiltes Paket zwischen den Containern.
+Wer es ändert, ändert BEIDE Dateien.
+
+Payload-Formate (dokumentiert, nicht geraten — AGENTS Regel D):
+- Discord: POST JSON {"content": "..."} — discord.com/developers/docs/resources/webhook
+- Slack:   POST JSON {"text": "..."}    — api.slack.com/messaging/webhooks
+- ntfy:    POST Roh-Text an https://ntfy.sh/<topic>, Titel via ?title= —
+           docs.ntfy.sh/publish
+- Generisch: POST JSON {"title", "message", "level"} für eigene Empfänger
+  (Home Assistant, n8n, eigene Skripte).
+"""
+
+import requests
+
+TIMEOUT_SEKUNDEN = 10
+
+
+def erkenne_webhook_typ(url: str) -> str:
+    """Erkennt den Dienst an der URL — der Nutzer muss nichts konfigurieren."""
+    u = url.lower()
+    if "discord.com/api/webhooks" in u or "discordapp.com/api/webhooks" in u:
+        return "discord"
+    if "hooks.slack.com" in u:
+        return "slack"
+    if "ntfy" in u:
+        return "ntfy"
+    return "generisch"
+
+
+def baue_payload(url: str, titel: str, text: str, level: str = "info"):
+    """Pure Funktion (testbar): (typ, json_payload) — ntfy sendet Roh-Text."""
+    typ = erkenne_webhook_typ(url)
+    if typ == "discord":
+        return typ, {"content": f"**{titel}**\n{text}"}
+    if typ == "slack":
+        return typ, {"text": f"*{titel}*\n{text}"}
+    if typ == "ntfy":
+        return typ, None
+    return typ, {"title": titel, "message": text, "level": level}
+
+
+def sende(url: str, titel: str, text: str, level: str = "info") -> None:
+    """Schickt die Nachricht; wirft RuntimeError mit Klartext bei Fehlern."""
+    typ, payload = baue_payload(url, titel, text, level)
+    try:
+        if typ == "ntfy":
+            antwort = requests.post(
+                url, data=text.encode("utf-8"),
+                params={"title": titel}, timeout=TIMEOUT_SEKUNDEN,
+            )
+        else:
+            antwort = requests.post(url, json=payload, timeout=TIMEOUT_SEKUNDEN)
+    except requests.RequestException as e:
+        raise RuntimeError(f"Webhook nicht erreichbar: {e}") from e
+    if antwort.status_code >= 300:
+        raise RuntimeError(
+            f"Webhook antwortete mit HTTP {antwort.status_code}: "
+            f"{(antwort.text or '')[:200]}"
+        )

docker/worker/tasks.py

@@ -13,12 +13,15 @@ komprimiert danach auf Arbeitsgröße. Die Rohdatei liegt nur temporär in
 """
 
 import glob
+import json
 import os
 import shutil
 
 import db
+import medien
+import notify
 from celery_app import celery_app
-from detection import detect_disc_type
+from detection import detect_disc_type, disc_size_bytes
 from ripping import (
     DEFAULT_HB_PRESET,
     RIP_OUTPUT_DIR,
@@ -41,37 +44,136 @@ def _zielbasis(target_dir, disc_type: str) -> str:
     return os.path.join(RIP_OUTPUT_DIR, disc_type)
 
 
+def _arbeitsverzeichnis(einstellungen: dict) -> str:
+    """Basis für Roh-Rips: UI-Setting `workDir` (unter /app/media, z. B. eine
+    NAS-Freigabe) schlägt den Container-Default /app/temp/raw.
+
+    Hintergrund (Commander 24.07.): Die VM-Platte (150 GB) reicht für BD-50,
+    aber eine 4K-UHD (bis 100 GB roh + Kompression daneben) sprengt sie —
+    das Arbeitsverzeichnis muss deshalb auf ein großes Ziel umlegbar sein.
+    """
+    work_dir = (einstellungen.get("workDir") or "").strip()
+    if work_dir:
+        normalisiert = os.path.normpath(work_dir)
+        if normalisiert.startswith(MEDIA_ROOT):
+            return normalisiert
+    return RAW_DIR
+
+
+def _frei_bytes(pfad: str) -> int:
+    """Freier Platz am Pfad (nächster existierender Elternordner zählt)."""
+    kandidat = pfad
+    while kandidat and not os.path.exists(kandidat):
+        kandidat = os.path.dirname(kandidat)
+    try:
+        return shutil.disk_usage(kandidat or "/").free
+    except OSError:
+        return -1
+
+
+def _platz_pruefen(pfad: str, benoetigt: int, zweck: str) -> str:
+    """Gibt eine Klartext-Fehlermeldung zurück, wenn der Platz nicht reicht —
+    sonst leeren String. VOR dem Rip geprüft: eine volle Platte nach 40 GB
+    ist der teuerste Fehlschlag, den es gibt."""
+    frei = _frei_bytes(pfad)
+    if frei < 0 or benoetigt <= 0:
+        return ""  # unbekannt → nicht raten, lieber rippen lassen
+    if frei >= benoetigt:
+        return ""
+    return (
+        f"Zu wenig Platz für {zweck} in {pfad}: "
+        f"{frei / 1024**3:.1f} GB frei, benötigt ~{benoetigt / 1024**3:.1f} GB. "
+        "Abhilfe: anderes Ziel wählen oder das Arbeitsverzeichnis unter "
+        "Einstellungen → Verarbeitung auf eine große Freigabe legen."
+    )
+
+
+def _makemkv_key_anwenden(einstellungen: dict) -> None:
+    """MakeMKV-Beta-Key aus den UI-Einstellungen aktivieren (schlägt Env).
+
+    Damit ist der Monats-Key ohne Rebuild/Neustart aktualisierbar
+    (Einstellungen → System). Format wie entrypoint.sh: settings.conf.
+    """
+    key = (einstellungen.get("makemkvAppKey") or "").strip()
+    if not key:
+        return
+    ordner = os.path.expanduser("~/.MakeMKV")
+    try:
+        os.makedirs(ordner, exist_ok=True)
+        with open(os.path.join(ordner, "settings.conf"), "w") as f:
+            f.write(f'app_Key = "{key}"\n')
+    except OSError as e:
+        db.add_log("warning", "worker", f"MakeMKV-Key konnte nicht gesetzt werden: {e}")
+
+
 def _abbruch_angefordert(job_id: str) -> bool:
     """Kooperativer Abbruch: hat der Nutzer über die API abgebrochen?"""
     return db.get_job_status(job_id) == "canceling"
 
 
+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()
+    url = (einstellungen.get("notificationWebhook") or "").strip()
+    if not url:
+        return
+    try:
+        notify.sende(url, betreff, text, level)
+    except Exception as e:
+        db.add_log("warning", "notify", f"Job {job_id}: Benachrichtigung fehlgeschlagen: {e}")
+
+
 def _job_abschliessen(job_id: str, ergebnis: dict) -> None:
-    """Schreibt den Endzustand eines Jobs (completed/failed) nach Postgres."""
+    """Schreibt den Endzustand eines Jobs (completed/failed) nach Postgres,
+    bereitet bei Erfolg fürs Medien-System auf (NFO/Poster) und meldet das
+    Ende per Webhook (falls konfiguriert)."""
+    job = db.get_job(job_id) or {}
+    titel = job.get("title") or job_id[:8]
+
     if ergebnis.get("status") == "cancelled":
         db.update_job(
             job_id, status="failed", error="Abgebrochen durch Nutzer",
             finished_at=db.utcnow(),
         )
         db.add_log("warning", "worker", f"Job {job_id}: abgebrochen — Rohdaten bleiben erhalten")
+        _benachrichtigen(job_id, f'⚠️ Rippy: „{titel}" abgebrochen',
+                         "Der Job wurde auf Wunsch abgebrochen — Rohdaten bleiben erhalten.",
+                         "warning")
         return
     if ergebnis.get("status") == "success":
+        ausgabe = ergebnis.get("output_dir")
+        if ausgabe and (job.get("disc_type") in ("dvd", "bluray")):
+            # Media-Server-Aufbereitung (Jellyfin/Emby/Kodi: NFO + Poster)
+            einstellungen = db.get_settings()
+            try:
+                meta = json.loads(job.get("meta") or "{}")
+            except ValueError:
+                meta = {}
+            for meldung in medien.aufbereiten(
+                ausgabe, einstellungen.get("mediaServer") or "none",
+                job.get("title") or "", meta.get("year"), meta,
+            ):
+                db.add_log("info", "worker", f"Job {job_id}: {meldung}")
         db.update_job(
             job_id,
             status="completed",
             progress=100,
-            output_path=ergebnis.get("output_dir"),
+            output_path=ausgabe,
             finished_at=db.utcnow(),
         )
-        db.add_log("success", "worker", f"Job {job_id}: abgeschlossen → {ergebnis.get('output_dir')}")
+        db.add_log("success", "worker", f"Job {job_id}: abgeschlossen → {ausgabe}")
+        _benachrichtigen(job_id, f'✅ Rippy: „{titel}" ist fertig',
+                         f"Abgelegt unter: {ausgabe}", "success")
     else:
+        fehler = ergebnis.get("error", "unbekannter Fehler")
         db.update_job(
             job_id,
             status="failed",
-            error=ergebnis.get("error", "unbekannter Fehler"),
+            error=fehler,
             finished_at=db.utcnow(),
         )
-        db.add_log("error", "worker", f"Job {job_id}: {ergebnis.get('error', 'unbekannter Fehler')}")
+        db.add_log("error", "worker", f"Job {job_id}: {fehler}")
+        _benachrichtigen(job_id, f'❌ Rippy: „{titel}" fehlgeschlagen', fehler, "error")
 
 
 @celery_app.task(bind=True, name="worker.tasks.rip_disc")
@@ -122,16 +224,51 @@ def rip_disc(self, device_path: str, job_id: str, target_dir: str = None):
         and einstellungen.get("transcodeEnabled", True)
     )
 
-    final_dir = os.path.join(_zielbasis(target_dir, disc_type), job_id)
+    if disc_type in ("dvd", "bluray"):
+        # UI-Key schlägt Env-Key — Monats-Key ohne Rebuild aktualisierbar
+        _makemkv_key_anwenden(einstellungen)
+
+    # Sprechender Zielordner „<Titel> (Jahr)" statt Job-UUID — Jellyfin & Co.
+    # erkennen den Film am Ordnernamen. UUID bleibt Fallback ohne Titel.
+    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,
+    )
+    # Geplantes Ziel sofort sichtbar machen (UI-Detail + retry-transcode)
+    db.update_job(job_id, output_path=final_dir)
+
+    raw_dir = os.path.join(_arbeitsverzeichnis(einstellungen), job_id)
+
+    # Platz-Check VOR dem Rip: Disc-Größe ist per ioctl bekannt — eine volle
+    # Platte nach 40 GB wäre der teuerste Fehlschlag (4K-UHD: bis 100 GB roh).
+    try:
+        disc_bytes = disc_size_bytes(device_path)
+    except OSError:
+        disc_bytes = 0
+    marge = 1024**3  # 1 GB Sicherheitsabstand
+    if disc_type in ("dvd", "bluray"):
+        rip_ziel = raw_dir if transcode_an else final_dir
+        fehler = _platz_pruefen(rip_ziel, disc_bytes + marge, "den Roh-Rip")
+        if not fehler and transcode_an and einstellungen.get("keepOriginal", False):
+            fehler = _platz_pruefen(final_dir, disc_bytes + marge, "das Original (keepOriginal)")
+        if fehler:
+            ergebnis = {"status": "error", "error": fehler}
+            _job_abschliessen(job_id, ergebnis)
+            return ergebnis
 
     if disc_type == "cd":
         ergebnis = rip_cd(device_path, job_id, progress_cb=fortschritt, output_dir=final_dir)
     elif transcode_an:
-        # Roh-Rip nach /app/temp (wird nach erfolgreicher Kompression gelöscht)
+        # Roh-Rip ins Arbeitsverzeichnis (wird nach erfolgreicher Kompression gelöscht)
         ergebnis = rip_video(
             device_path, job_id, disc_type,
             progress_cb=fortschritt,
-            output_dir=os.path.join(RAW_DIR, job_id),
+            output_dir=raw_dir,
         )
     else:
         ergebnis = rip_video(
@@ -145,10 +282,10 @@ def rip_disc(self, device_path: str, job_id: str, target_dir: str = None):
         db.update_job(job_id, status="transcoding", progress=0)
         db.add_log("info", "worker", f"Job {job_id}: Rip fertig, Kompression eingereiht")
         transcode_files.apply_async(
-            args=[job_id, os.path.join(RAW_DIR, job_id), final_dir],
+            args=[job_id, raw_dir, final_dir],
             queue="transcode",
         )
-        return {"status": "ripped", "raw_dir": os.path.join(RAW_DIR, job_id)}
+        return {"status": "ripped", "raw_dir": raw_dir}
 
     _job_abschliessen(job_id, ergebnis)
     return ergebnis

docker/worker/test_medien.py

@@ -0,0 +1,57 @@
+"""Tests für die Media-Server-Aufbereitung (Benennung + NFO)."""
+
+import os
+
+from medien import baue_nfo, sicherer_name, zielordner
+
+
+def test_sicherer_name_entfernt_verbotene_zeichen():
+    assert sicherer_name('Alien: Die Wiedergeburt') == "Alien Die Wiedergeburt"
+    assert sicherer_name('Was/ist\\das?<>|*"') == "Wasistdas"
+
+
+def test_sicherer_name_mit_jahr():
+    assert sicherer_name("Evangelion 2.22", 2009) == "Evangelion 2.22 (2009)"
+
+
+def test_sicherer_name_kollabiert_leerraum_und_punkte():
+    assert sicherer_name("  Viel   Raum ...  ") == "Viel Raum"
+
+
+def test_sicherer_name_leer_bleibt_leer():
+    assert sicherer_name("") == ""
+    assert sicherer_name("???") == ""
+
+
+def test_zielordner_nutzt_titel_und_jahr(tmp_path):
+    pfad = zielordner(str(tmp_path), "Inception", 2010, "abc-123")
+    assert pfad == os.path.join(str(tmp_path), "Inception (2010)")
+
+
+def test_zielordner_faellt_auf_job_id_zurueck(tmp_path):
+    pfad = zielordner(str(tmp_path), "", None, "abc-123")
+    assert pfad == os.path.join(str(tmp_path), "abc-123")
+
+
+def test_zielordner_weicht_bei_kollision_aus(tmp_path):
+    os.makedirs(tmp_path / "Inception (2010)")
+    pfad = zielordner(str(tmp_path), "Inception", 2010, "abcdef12-3456")
+    assert pfad == os.path.join(str(tmp_path), "Inception (2010) [abcdef12]")
+
+
+def test_baue_nfo_film_mit_plot_und_genres():
+    nfo = baue_nfo(
+        {"overview": "Ein Traum <im> Traum & so", "genres": ["Sci-Fi", "Action"]},
+        "Inception", 2010,
+    )
+    assert "<movie>" in nfo and "</movie>" in nfo
+    assert "<title>Inception</title>" in nfo
+    assert "<year>2010</year>" in nfo
+    # XML-Escaping: <, >, & dürfen den Parser nicht sprengen
+    assert "Ein Traum &lt;im&gt; Traum &amp; so" in nfo
+    assert "<genre>Sci-Fi</genre>" in nfo
+
+
+def test_baue_nfo_serie_bekommt_tvshow_wurzel():
+    nfo = baue_nfo({"type": "tv"}, "Neon Genesis Evangelion", 1995)
+    assert "<tvshow>" in nfo and "</tvshow>" in nfo

docker/worker/test_notify.py

@@ -0,0 +1,38 @@
+"""Tests für die Webhook-Benachrichtigungen (Typ-Erkennung + Payload-Bau)."""
+
+from notify import baue_payload, erkenne_webhook_typ
+
+
+def test_discord_wird_an_url_erkannt():
+    assert erkenne_webhook_typ("https://discord.com/api/webhooks/1/abc") == "discord"
+    assert erkenne_webhook_typ("https://discordapp.com/api/webhooks/1/abc") == "discord"
+
+
+def test_slack_und_ntfy_und_generisch():
+    assert erkenne_webhook_typ("https://hooks.slack.com/services/T/B/x") == "slack"
+    assert erkenne_webhook_typ("https://ntfy.sh/mein-thema") == "ntfy"
+    assert erkenne_webhook_typ("https://ha.local/api/webhook/rippy") == "generisch"
+
+
+def test_discord_payload_nutzt_content():
+    typ, payload = baue_payload("https://discord.com/api/webhooks/1/a", "Titel", "Text")
+    assert typ == "discord"
+    assert payload == {"content": "**Titel**\nText"}
+
+
+def test_slack_payload_nutzt_text():
+    typ, payload = baue_payload("https://hooks.slack.com/services/x", "Titel", "Text")
+    assert typ == "slack"
+    assert payload == {"text": "*Titel*\nText"}
+
+
+def test_ntfy_sendet_rohtext():
+    typ, payload = baue_payload("https://ntfy.sh/thema", "Titel", "Text")
+    assert typ == "ntfy"
+    assert payload is None  # Roh-Text-Body, kein JSON
+
+
+def test_generischer_payload_traegt_level():
+    typ, payload = baue_payload("https://example.org/hook", "Titel", "Text", "error")
+    assert typ == "generisch"
+    assert payload == {"title": "Titel", "message": "Text", "level": "error"}