discstation 0.1.35 → 0.1.37

package/src/discstation.py

@@ -3,6 +3,7 @@ import argparse
 import atexit
 import collections
 import concurrent.futures
+import contextlib
 import errno
 try:
     import fcntl  # POSIX-only; used only in drive_status()'s Linux branch
@@ -12,10 +13,6 @@ import json
 import mimetypes
 import os
 import signal
-try:
-    import pwd
-except ImportError:
-    pwd = None
 import re
 import shutil
 import socket
@@ -27,6 +24,7 @@ import subprocess
 import sys
 import tempfile
 import time
+import types
 import datetime
 from pathlib import Path
 from queue import Queue, Empty, Full
@@ -819,53 +817,6 @@ def safe_send(ser, msg):
 discstation_burn.status_sink = _record_web_status
 
 
-def run_as_desktop_user(cmd):
-    if os.name != "posix" or pwd is None:
-        return cmd
-    sudo_user = os.environ.get("SUDO_USER")
-    if os.geteuid() == 0 and sudo_user and sudo_user != "root":
-        home = Path(discstation_burn.USER_HOME)
-        uid = pwd.getpwnam(sudo_user).pw_uid
-        return [
-            "sudo", "-u", sudo_user,
-            "env",
-            "DISPLAY=" + os.environ.get("DISPLAY", ":0"),
-            "XAUTHORITY=" + str(home / ".Xauthority"),
-            "XDG_RUNTIME_DIR=/run/user/" + str(uid),
-            *cmd,
-        ]
-    return cmd
-
-
-def chown_to_sudo_user(path):
-    sudo_user = os.environ.get("SUDO_USER")
-    if os.name != "posix" or pwd is None or not hasattr(os, "geteuid"):
-        return
-    if os.geteuid() != 0 or not sudo_user or sudo_user == "root":
-        return
-
-    try:
-        pw_record = pwd.getpwnam(sudo_user)
-    except KeyError:
-        return
-
-    uid = pw_record.pw_uid
-    gid = pw_record.pw_gid
-    root_path = Path(path)
-
-    for current_root, dirs, files in os.walk(root_path):
-        try:
-            os.chown(current_root, uid, gid)
-        except OSError:
-            pass
-        for name in dirs + files:
-            item = Path(current_root) / name
-            try:
-                os.chown(item, uid, gid)
-            except OSError:
-                pass
-
-
 def _mpv_ipc(payload, timeout=None):
     """Send one JSON line to mpv's IPC endpoint. Windows = named pipe, POSIX =
     AF_UNIX socket. Returns the raw reply bytes (b"" if not read), or raises OSError."""
@@ -936,7 +887,7 @@ def read_serial_line(ser, timeout=0.1):
     # Always make at least one non-blocking pass, even for timeout<=0 - the
     # `remaining <= 0: break` at the bottom still ends it after that pass.
     # (`while time.monotonic() < deadline` used to skip the body entirely for
-    # timeout=0, which is exactly how _check_cancel() calls this - so cancel
+    # timeout=0, which is exactly how check_cancel() calls this - so cancel
     # detection during rips silently never read the port.)
     while True:
         if _line_buf:
@@ -1174,6 +1125,67 @@ def append_burn_history(entry):
         f.write(json.dumps(entry) + "\n")
 
 
+@contextlib.contextmanager
+def _burn_history(entry, swallow_cancel=False):
+    """Record a burn attempt in the history file however the block ends
+    (success / cancelled / error). `entry` holds the fixed fields (title,
+    disc_type, mode, speed, ...). A cancelled burn re-raises unless
+    swallow_cancel, in which case the caller checks `.cancelled` and returns."""
+    start = time.time()
+    outcome = types.SimpleNamespace(cancelled=False)
+
+    def record(ok, error=None):
+        row = {"timestamp": datetime.datetime.now().isoformat(), **entry,
+               "success": ok, "duration_s": round(time.time() - start)}
+        if error:
+            row["error"] = error
+        append_burn_history(row)
+
+    try:
+        yield outcome
+    except (KeyboardInterrupt, SystemExit):
+        record(False, "Cancelled")
+        raise
+    except CancelError:
+        record(False, "Cancelled")
+        if not swallow_cancel:
+            raise
+        outcome.cancelled = True
+    except Exception as e:
+        record(False, str(e)[:100])
+        raise
+    else:
+        record(True)
+
+
+def _wait_for_start(ser, starting=None, mode=None):
+    """Wait on the remote for START (CANCEL/STOP aborts). Returns
+    (mode, speed) - speed is None unless a SPEED: line came first - or None if
+    the user cancelled. A non-None `mode` (the video flow's) may also be set by
+    MODE:<m> / START:<m>. `starting` names the burn in the status line
+    (defaults to the mode)."""
+    speed = None
+    print("Waiting for burn START button...")
+    while True:
+        line = wait_for_button(ser)
+        if line in ("CANCEL", "PLAY_STOP"):
+            safe_send(ser, "CANCELLED:Cancelled")
+            print("Burn cancelled by user")
+            return None
+        if line.startswith("MODE:") and mode is not None:
+            mode = discstation_burn.normalize_mode(line.split(":", 1)[1])
+            print(f"Burn mode: {mode}")
+        elif line.startswith("SPEED:"):
+            speed = line.split(":", 1)[1].strip()
+            print(f"Burn speed: {speed}")
+        elif line == "START" or line.startswith("START:"):
+            if mode is not None and ":" in line:
+                mode = discstation_burn.normalize_mode(line.split(":", 1)[1])
+            print(f"Starting {starting or mode} burn")
+            send(ser, f"STATUS:Starting {starting or mode}...")
+            return mode, speed
+
+
 def run_probe(cmd, timeout=8, name=None):
     try:
         return subprocess.run(
@@ -1293,60 +1305,6 @@ def _device_present(device):
         return False
 
 
-def _tray_closed_with_disc(device):
-    if not device:
-        return False
-    global _tray_open
-    if not _device_present(device):
-        return False
-    properties = udev_cdrom_properties(device)
-    if properties.get("ID_CDROM_MEDIA") == "1":
-        _tray_open = False
-        return True
-    if properties.get("ID_CDROM_MEDIA_STATE") == "blank":
-        _tray_open = False
-        return True
-    return False
-
-
-def disc_present(device):
-    if not device:
-        return False
-    if _tray_closed_with_disc(device):
-        return True
-    if _tray_open:
-        return False
-    if not _device_present(device):
-        return False
-    if discstation_host.system_name() != "linux":
-        properties = udev_cdrom_properties(device)
-        return properties.get("ID_CDROM_MEDIA") == "1"
-
-    toc = run_probe(["wodim", "-toc", "dev=" + device], name="wodim-toc", timeout=PROBE_TIMEOUT_WODIM_TOC)
-    toc_text = ensure_text(toc.stdout) + ensure_text(toc.stderr)
-    no_media_markers = _NO_MEDIA_MARKERS
-    if toc.returncode == 124:
-        return is_blank_disc(device)
-    if toc_text.strip() and any(marker in toc_text.lower() for marker in no_media_markers):
-        return False
-
-    dvd = run_probe(["lsdvd", device], name="lsdvd", timeout=PROBE_TIMEOUT_LSDVD)
-    if dvd.returncode == 0:
-        return True
-
-    fs = run_probe(["blkid", "-o", "value", "-s", "TYPE", device], name="blkid", timeout=PROBE_TIMEOUT_BLKID)
-    if fs.returncode == 0 and ensure_text(fs.stdout).strip():
-        return True
-
-    if "first:" in toc_text and "track:" in toc_text:
-        return True
-
-    if toc_text.strip() and not any(marker in toc_text.lower() for marker in no_media_markers):
-        return True
-
-    return is_blank_disc(device)
-
-
 def is_blank_disc(device):
     if not device:
         return False
@@ -1915,9 +1873,6 @@ def menu_items_for_disc(device):
         props = udev_cdrom_properties(device)
         is_cd = props.get("ID_CDROM_MEDIA_CD_R") == "1" or props.get("ID_CDROM_MEDIA_CD_RW") == "1"
         items = ["BURN DATA", "BURN AUDIO"] if is_cd else ["BURN", "BURN DATA"]
-        had = discstation_burn.WORK.rglob("movie.mpg")
-        if any(True for _ in had):
-            items.append("BURN MPG")
     elif kind in ("dvd_video", "audio_cd", "vcd", "svcd", "video_data", "data_disc", "data_cd"):
         items = ["PLAY", "RIP"]
     else:
@@ -2217,10 +2172,6 @@ def _release_meta(release, track_count, toc=None):
     return None
 
 
-# Back-compat alias (older name).
-metadata_from_musicbrainz_release = _release_meta
-
-
 def musicbrainz_release_details(release_id):
     if _mb is not None:
         return _mb.get_release_by_id(
@@ -2277,58 +2228,6 @@ def musicbrainz_lookup(device, track_count):
     return None
 
 
-def musicbrainz_lookup_by_album_hints(album_artist, album, track_count):
-    if not album:
-        return None
-
-    if _mb is not None:
-        fields = {"release": album}
-        if album_artist:
-            fields["artist"] = album_artist
-        try:
-            hits = _mb.search_releases(limit=8, **fields).get("release-list", [])
-        except _mb.WebServiceError as e:
-            print(f"MusicBrainz search failed: {e}")
-            hits = []
-        for hit in hits:
-            release_id = hit.get("id")
-            if not release_id:
-                continue
-            try:
-                details = musicbrainz_release_details(release_id)
-            except Exception:
-                continue
-            metadata = _release_meta(details, track_count)
-            if metadata:
-                metadata["source"] = "musicbrainz-search"
-                return metadata
-        return None
-
-    # --- fallback: raw ws/2 search ---
-    query_parts = [f'release:"{album}"']
-    if album_artist:
-        query_parts.append(f'artist:"{album_artist}"')
-    response = requests.get(
-        "https://musicbrainz.org/ws/2/release/",
-        params={"query": " AND ".join(query_parts), "fmt": "json", "limit": 8},
-        headers={"User-Agent": USER_AGENT}, timeout=20,
-    )
-    response.raise_for_status()
-    for release in response.json().get("releases", []):
-        release_id = release.get("id")
-        if not release_id:
-            continue
-        try:
-            details = musicbrainz_release_details(release_id)
-        except Exception:
-            continue
-        metadata = _release_meta(details, track_count)
-        if metadata:
-            metadata["source"] = "musicbrainz-search"
-            return metadata
-        time.sleep(1)
-    return None
-
 def cddb_sum(value):
     return sum(int(ch) for ch in str(value))
 
@@ -2461,7 +2360,7 @@ def musicbrainz_release_id_search(album_artist, album):
     return releases[0].get("id") if releases else None
 
 
-def audio_metadata_lookup(device, track_count, artist_hint=None, album_hint=None):
+def audio_metadata_lookup(device, track_count):
     metadata = None
 
     for attempt in range(2):
@@ -2474,17 +2373,6 @@ def audio_metadata_lookup(device, track_count, artist_hint=None, album_hint=None
                 print(f"MusicBrainz lookup failed, retrying... ({e})")
                 time.sleep(1)
 
-    if not metadata and album_hint:
-        for attempt in range(2):
-            try:
-                metadata = musicbrainz_lookup_by_album_hints(artist_hint, album_hint, track_count)
-                if metadata:
-                    break
-            except Exception as e:
-                if attempt == 0:
-                    print(f"MusicBrainz album search failed, retrying... ({e})")
-                    time.sleep(1)
-
     if metadata and not metadata.get("release_id"):
         try:
             metadata["release_id"] = musicbrainz_release_id_search(
@@ -2599,60 +2487,6 @@ def tag_flac(path, track_meta, album_meta, cover_path):
     audio.save()
 
 
-def retag_audio_rip(rip_dir, artist_hint, album_hint):
-    rip_dir = Path(rip_dir)
-    flacs = sorted(rip_dir.glob("*.flac"))
-    if not flacs:
-        raise RuntimeError(f"No FLAC files found in {rip_dir}")
-    if not album_hint:
-        raise RuntimeError("Retag needs --album")
-
-    metadata = musicbrainz_lookup_by_album_hints(artist_hint, album_hint, len(flacs))
-    if not metadata:
-        raise RuntimeError("Could not find album metadata")
-
-    target_dir = unique_dir(RIP_ROOT / safe_path_name(f"{metadata['album_artist']} - {metadata['album']}"))
-    if rip_dir != target_dir:
-        rip_dir.rename(target_dir)
-    else:
-        target_dir = rip_dir
-
-    write_album_info(target_dir, metadata)
-    cover_path = download_cover_art(
-        metadata.get("release_id"),
-        target_dir,
-        metadata.get("release_group_id"),
-    )
-
-    renamed = []
-    for index, src in enumerate(sorted(target_dir.glob("*.flac")), start=1):
-        if index > len(metadata["tracks"]):
-            break
-
-        track_meta = metadata["tracks"][index - 1]
-        out_file = target_dir / f"{index:02d} - {safe_path_name(track_meta['title'])}.flac"
-        if src != out_file:
-            if out_file.exists():
-                out_file.unlink()
-            src.rename(out_file)
-
-        tag_flac(out_file, track_meta, metadata, cover_path)
-        renamed.append(out_file)
-
-    chown_to_sudo_user(target_dir)
-    return target_dir, cover_path, renamed
-
-
-def latest_audio_rip_dir():
-    candidates = sorted(
-        path for path in RIP_ROOT.glob("audio_cd_*")
-        if path.is_dir() and list(path.glob("*.flac"))
-    )
-    if not candidates:
-        raise RuntimeError("No audio_cd_* rip folders found")
-    return candidates[-1]
-
-
 def parse_ffmpeg_time(line):
     marker = "time="
     if marker not in line:
@@ -2668,41 +2502,22 @@ def parse_ffmpeg_time(line):
 from discstation_burn import CancelError
 
 
-def _check_cancel(ser):
-    try:
-        line = read_serial_line(ser, timeout=0)
-        return line in ("CANCEL", "PLAY_STOP") if line else False
-    except OSError:
-        return False
-
-
 def _raise_if_cancelled(ser):
     """Poll for a CANCEL press between blocking phases that have no
     subprocess loop of their own (metadata lookups, scans, cover-art
     downloads). Doesn't interrupt a call in progress, but catches the press
     the moment the phase returns."""
-    if _check_cancel(ser):
+    if discstation_burn.check_cancel(ser):
         raise CancelError
 
 
 def iter_process_events(proc, idle_seconds=1.0, ser=None):
-    lines = Queue()
-    finished = object()
-
-    def read_output():
-        try:
-            for line in proc.stdout:
-                lines.put(line.rstrip("\r\n"))
-        finally:
-            lines.put(finished)
-
-    reader = threading.Thread(target=read_output, daemon=True)
-    reader.start()
+    lines, finished = discstation_burn.proc_line_queue(proc)
     last_ping = time.time()
     output_done = False
     while proc.poll() is None or not output_done:
         if ser is not None:
-            if _check_cancel(ser):
+            if discstation_burn.check_cancel(ser):
                 discstation_burn.stop_process(proc)
                 raise CancelError
             if time.time() - last_ping >= 5:
@@ -2717,7 +2532,6 @@ def iter_process_events(proc, idle_seconds=1.0, ser=None):
             output_done = True
         else:
             yield line
-    reader.join(timeout=1)
 
 
 def rip_device(device):
@@ -2751,33 +2565,22 @@ def directory_size_bytes(path):
     return total
 
 
-def _stdin_is_tty():
-    """sys.stdin is None under pythonw.exe (no console) - plain .isatty() would
-    AttributeError. Also guards a closed/redirected stdin under systemd/launchd."""
-    try:
-        return sys.stdin is not None and sys.stdin.isatty()
-    except (AttributeError, ValueError, OSError):
-        return False
+def _wait_for_source(ser, missing="URL or file path"):
+    """Block until the web remote supplies a source (an upload dir or a pasted
+    URL/path). Returns None - after telling the remote why - if the user
+    cancelled or sent nothing."""
+    url = wait_for_web_url(ser)
+    if url is None:
+        safe_send(ser, "CANCELLED:Cancelled")
+    elif not url:
+        safe_send(ser, f"ERROR:Need {missing}")
+    return url or None
 
 
-def burn_flow(ser, url):
+def burn_flow(ser):
+    url = _wait_for_source(ser)
     if not url:
-        if _stdin_is_tty():
-            safe_send(ser, "STATUS:Enter URL or file path in terminal")
-            print("=== Enter URL or file path below, then press Enter ===")
-            try:
-                url = sys.stdin.readline().strip()
-            except (EOFError, KeyboardInterrupt, OSError):
-                safe_send(ser, "CANCELLED:Cancelled")
-                return
-        else:
-            url = wait_for_web_url(ser)
-            if url is None:
-                safe_send(ser, "CANCELLED:Cancelled")
-                return
-            if not url:
-                safe_send(ser, "ERROR:Need URL or file path")
-                return
+        return
 
     device = discstation_burn.disc_device()
     disc_bytes = discstation_burn.disc_capacity_bytes(device)
@@ -2837,31 +2640,13 @@ def burn_flow(ser, url):
         except RuntimeError:
             pass
 
-    selected_mode = "AUTO"
-    burn_speed = None
-    print("Waiting for burn START button...")
-    while True:
-        line = wait_for_button(ser)
-        if line == "CANCEL" or line == "PLAY_STOP":
-            safe_send(ser, "CANCELLED:Cancelled")
-            print("Burn cancelled by user")
-            return
-        if line.startswith("MODE:"):
-            selected_mode = discstation_burn.normalize_mode(line.split(":", 1)[1])
-            print(f"Burn mode: {selected_mode}")
-        elif line.startswith("SPEED:"):
-            burn_speed = line.split(":", 1)[1].strip()
-            print(f"Burn speed: {burn_speed}")
-        elif line == "START" or line.startswith("START:"):
-            if ":" in line:
-                selected_mode = discstation_burn.normalize_mode(line.split(":", 1)[1])
-            print(f"Starting burn flow in {selected_mode} mode")
-            send(ser, f"STATUS:Starting {selected_mode}...")
-            break
+    started = _wait_for_start(ser, mode="AUTO")
+    if not started:
+        return
+    selected_mode, burn_speed = started
 
-    start_time = time.time()
     disc_type_label = "DL" if dl_info["is_dual_layer"] else "SL"
-    try:
+    with _burn_history({"title": title, "disc_type": disc_type_label, "mode": selected_mode, "speed": burn_speed or "Auto"}):
         plan = discstation_burn.bitrate_plan(duration, selected_mode, disc_bytes)
         video = discstation_burn.download(ser, url, job_dir)
         mpg, dvd_aspect = discstation_burn.convert(ser, video, job_dir, selected_mode, disc_bytes)
@@ -2885,121 +2670,9 @@ def burn_flow(ser, url):
             safe_send(ser, "DONE:Test complete!")
             print(f"Test complete. DVD folder: {dvd_dir}")
 
-        append_burn_history({
-            "timestamp": datetime.datetime.now().isoformat(),
-            "title": title,
-            "disc_type": disc_type_label,
-            "mode": selected_mode,
-            "speed": burn_speed or "Auto",
-            "success": True,
-            "duration_s": round(time.time() - start_time),
-        })
-    except (KeyboardInterrupt, SystemExit):
-        append_burn_history({
-            "timestamp": datetime.datetime.now().isoformat(),
-            "title": title,
-            "disc_type": disc_type_label,
-            "mode": selected_mode,
-            "speed": burn_speed or "Auto",
-            "success": False,
-            "error": "Cancelled",
-            "duration_s": round(time.time() - start_time),
-        })
-        raise
-    except Exception as e:
-        append_burn_history({
-            "timestamp": datetime.datetime.now().isoformat(),
-            "title": title,
-            "disc_type": disc_type_label,
-            "mode": selected_mode,
-            "speed": burn_speed or "Auto",
-            "success": False,
-            "error": str(e)[:100],
-            "duration_s": round(time.time() - start_time),
-        })
-        raise
-
     time.sleep(3)
 
 
-def _mpg_label(job_dir):
-    label = "DVD_VIDEO"
-    dl = job_dir / "download"
-    if dl.is_dir():
-        for f in sorted(dl.iterdir()):
-            if f.suffix.lower() in discstation_burn.VIDEO_EXTS:
-                label = discstation_burn.sanitize_disc_label(f.stem)
-                break
-        else:
-            for f in sorted(dl.iterdir()):
-                label = discstation_burn.sanitize_disc_label(f.stem)
-                break
-    if label == "DVD_VIDEO" or not label:
-        label = discstation_burn.sanitize_disc_label(job_dir.name)
-    return label
-
-
-def burn_mpg_flow(ser):
-    jobs = sorted(discstation_burn.WORK.glob("job_*"), reverse=True)
-    candidates = []
-    for jd in jobs:
-        mpg = jd / "movie.mpg"
-        if mpg.exists():
-            label = _mpg_label(jd)
-            candidates.append((mpg, label))
-    names = [c[1][:20] for c in candidates] + ["Enter path..."]
-    safe_send(ser, f"MENU_ITEMS:{','.join(names)}")
-    safe_send(ser, "HOME:Select MPG to burn")
-    mpg = None
-    disc_label = None
-    while True:
-        line = read_serial_line(ser, timeout=0.5)
-        if not line:
-            continue
-        if line.startswith("SELECT:"):
-            sel = line.split(":", 1)[1].strip()
-            if sel == "Enter path...":
-                path_str = wait_for_web_url(ser)
-                if path_str is None:
-                    refresh_main_menu(ser)
-                    return
-                path_str = path_str.strip()
-                p = Path(path_str)
-                if not p.exists():
-                    safe_send(ser, "ERROR:Path not found")
-                    time.sleep(2)
-                    continue
-                if p.is_dir():
-                    mpg = p / "movie.mpg"
-                    if not mpg.exists():
-                        safe_send(ser, "ERROR:No movie.mpg in dir")
-                        time.sleep(2)
-                        continue
-                elif p.suffix.lower() == ".mpg":
-                    mpg = p
-                else:
-                    safe_send(ser, "ERROR:Not an .mpg file")
-                    time.sleep(2)
-                    continue
-                disc_label = discstation_burn.sanitize_disc_label(mpg.stem)
-                break
-            else:
-                idx = next((i for i, n in enumerate(candidates) if n[1][:20] == sel), None)
-                if idx is not None:
-                    mpg, disc_label = candidates[idx]
-                    break
-        elif line == "CANCEL":
-            safe_send(ser, "CANCELLED:Cancelled")
-            refresh_main_menu(ser)
-            return
-        time.sleep(0.05)
-
-    device = discstation_burn.disc_device()
-    dl_info = discstation_burn.detect_disc_type(device)
-    disc_bytes = dl_info["capacity"]
-    discstation_burn.remux_and_burn(ser, mpg, disc_label, disc_bytes, dl_info)
-
-
 def _copy_to_job(ser, src, dst_dir):
     if src.is_dir():
         items = sorted(src.iterdir())
@@ -3015,25 +2688,9 @@ def _copy_to_job(ser, src, dst_dir):
 def burn_data_flow(ser):
     global _last_upload_label
 
-    if _stdin_is_tty():
-        safe_send(ser, "STATUS:Enter URL or file path in terminal")
-        print("=== Enter URL or file path below, then press Enter ===")
-        try:
-            url = sys.stdin.readline().strip()
-        except (EOFError, KeyboardInterrupt, OSError):
-            safe_send(ser, "CANCELLED:Cancelled")
-            return
-        if not url:
-            safe_send(ser, "ERROR:Need URL or file path")
-            return
-    else:
-        url = wait_for_web_url(ser)
-        if url is None:
-            safe_send(ser, "CANCELLED:Cancelled")
-            return
-        if not url:
-            safe_send(ser, "ERROR:Need URL or file path")
-            return
+    url = _wait_for_source(ser)
+    if not url:
+        return
 
     device = discstation_burn.disc_device()
     dl_info = discstation_burn.detect_disc_type(device)
@@ -3062,21 +2719,10 @@ def burn_data_flow(ser):
 
     send(ser, f"TITLE:{title}")
 
-    burn_speed = None
-    print("Waiting for burn START button...")
-    while True:
-        line = wait_for_button(ser)
-        if line == "CANCEL" or line == "PLAY_STOP":
-            safe_send(ser, "CANCELLED:Cancelled")
-            print("Burn cancelled by user")
-            return
-        if line.startswith("SPEED:"):
-            burn_speed = line.split(":", 1)[1].strip()
-            print(f"Burn speed: {burn_speed}")
-        elif line == "START" or line.startswith("START:"):
-            print("Starting data burn...")
-            send(ser, "STATUS:Starting data burn...")
-            break
+    started = _wait_for_start(ser, "data burn")
+    if not started:
+        return
+    burn_speed = started[1]
 
     if not can_burn_disc(device):
         raise RuntimeError("No writable disc in drive")
@@ -3087,8 +2733,7 @@ def burn_data_flow(ser):
     download_dir = job_dir / "download"
     download_dir.mkdir()
 
-    start_time = time.time()
-    try:
+    with _burn_history({"title": title, "disc_type": "Data DVD", "mode": "DATA", "speed": burn_speed or "Auto"}, swallow_cancel=True) as h:
         is_dir = local_path.is_dir() if local_path.exists() else False
         if is_dir:
             files_to_burn = [local_path]
@@ -3130,75 +2775,15 @@ def burn_data_flow(ser):
         safe_send(ser, "DONE:Data disc complete!")
         print("Data burn complete.")
 
-        append_burn_history({
-            "timestamp": datetime.datetime.now().isoformat(),
-            "title": title,
-            "disc_type": "Data DVD",
-            "mode": "DATA",
-            "speed": burn_speed or "Auto",
-            "success": True,
-            "duration_s": round(time.time() - start_time),
-        })
-    except (KeyboardInterrupt, SystemExit):
-        append_burn_history({
-            "timestamp": datetime.datetime.now().isoformat(),
-            "title": title,
-            "disc_type": "Data DVD",
-            "mode": "DATA",
-            "speed": burn_speed or "Auto",
-            "success": False,
-            "error": "Cancelled",
-            "duration_s": round(time.time() - start_time),
-        })
-        raise
-    except CancelError:
-        append_burn_history({
-            "timestamp": datetime.datetime.now().isoformat(),
-            "title": title,
-            "disc_type": "Data DVD",
-            "mode": "DATA",
-            "speed": burn_speed or "Auto",
-            "success": False,
-            "error": "Cancelled",
-            "duration_s": round(time.time() - start_time),
-        })
+    if h.cancelled:
         return
-    except Exception as e:
-        append_burn_history({
-            "timestamp": datetime.datetime.now().isoformat(),
-            "title": title,
-            "disc_type": "Data DVD",
-            "mode": "DATA",
-            "speed": burn_speed or "Auto",
-            "success": False,
-            "error": str(e)[:100],
-            "duration_s": round(time.time() - start_time),
-        })
-        raise
-
     time.sleep(3)
 
 
 def burn_audio_flow(ser):
-    if _stdin_is_tty():
-        safe_send(ser, "STATUS:Enter path to audio files in terminal")
-        print("=== Enter path to audio files/folder, then press Enter ===")
-        try:
-            url = sys.stdin.readline().strip()
-        except (EOFError, KeyboardInterrupt, OSError):
-            safe_send(ser, "CANCELLED:Cancelled")
-            return
-        if not url:
-            safe_send(ser, "ERROR:Need path to audio files")
-            return
-    else:
-        url = wait_for_web_url(ser)
-        if url is None:
-            safe_send(ser, "CANCELLED:Cancelled")
-            return
-        if not url:
-            safe_send(ser, "ERROR:Need path to audio files")
-            return
+    url = _wait_for_source(ser, "path to audio files")
+    if not url:
+        return
 
     src_path = Path(url)
     if not src_path.exists():
@@ -3261,18 +2846,10 @@ def burn_audio_flow(ser):
     send(ser, f"META:Dur {mins}m{secs}s")
     send(ser, f"FIT:CD-R {fits}")
 
-    burn_speed = None
-    print("Waiting for START button...")
-    while True:
-        line = wait_for_button(ser)
-        if line == "CANCEL" or line == "PLAY_STOP":
-            safe_send(ser, "CANCELLED:Cancelled")
-            return
-        if line.startswith("SPEED:"):
-            burn_speed = line.split(":", 1)[1].strip()
-        elif line == "START" or line.startswith("START:"):
-            send(ser, "STATUS:Starting audio burn...")
-            break
+    started = _wait_for_start(ser, "audio burn")
+    if not started:
+        return
+    burn_speed = started[1]
 
     device = discstation_burn.disc_device()
     if not can_burn_disc(device):
@@ -3280,95 +2857,23 @@ def burn_audio_flow(ser):
     if total_dur > 4740:
         raise RuntimeError(f"Too long for CD-R: {int(total_dur/60)}m{int(total_dur%60)}s > 79m")
 
-    start_time = time.time()
-    try:
+    entry = {"title": disc_label, "fingerprint": fingerprint, "track_titles": track_titles,
+             "disc_type": "Audio CD", "mode": "AUDIO", "speed": burn_speed or "Auto"}
+    with _burn_history(entry, swallow_cancel=True) as h:
         discstation_burn.burn_audio_cd(ser, audio_files, disc_label, burn_speed)
         safe_send(ser, "DONE:Audio CD complete!")
-        append_burn_history({
-            "timestamp": datetime.datetime.now().isoformat(),
-            "title": disc_label,
-            "fingerprint": fingerprint,
-            "track_titles": track_titles,
-            "disc_type": "Audio CD",
-            "mode": "AUDIO",
-            "speed": burn_speed or "Auto",
-            "success": True,
-            "duration_s": round(time.time() - start_time),
-        })
-    except (KeyboardInterrupt, SystemExit):
-        raise
-    except CancelError:
-        append_burn_history({
-            "timestamp": datetime.datetime.now().isoformat(),
-            "title": disc_label,
-            "fingerprint": fingerprint,
-            "track_titles": track_titles,
-            "disc_type": "Audio CD",
-            "mode": "AUDIO",
-            "speed": burn_speed or "Auto",
-            "success": False,
-            "error": "Cancelled",
-            "duration_s": round(time.time() - start_time),
-        })
+    if h.cancelled:
         return
-    except Exception as e:
-        append_burn_history({
-            "timestamp": datetime.datetime.now().isoformat(),
-            "title": disc_label,
-            "fingerprint": fingerprint,
-            "track_titles": track_titles,
-            "disc_type": "Audio CD",
-            "mode": "AUDIO",
-            "speed": burn_speed or "Auto",
-            "success": False,
-            "error": str(e)[:100],
-            "duration_s": round(time.time() - start_time),
-        })
-        raise
-
     time.sleep(3)
 
 
-def _iter_proc_lines(proc, ser):
-    lines = Queue()
-    finished = object()
-
-    def read_output():
-        try:
-            for line in proc.stdout:
-                lines.put(line.rstrip("\r\n"))
-        finally:
-            lines.put(finished)
-
-    reader = threading.Thread(target=read_output, daemon=True)
-    reader.start()
-    last_ping = time.time()
-    output_done = False
-    while proc.poll() is None or not output_done:
-        if time.time() - last_ping >= 5:
-            discstation_burn.send(ser, "PING")
-            last_ping = time.time()
-        if _check_cancel(ser):
-            discstation_burn.stop_process(proc)
-            return
-        try:
-            line = lines.get(timeout=0.5)
-        except Empty:
-            continue
-        if line is finished:
-            output_done = True
-        else:
-            yield line
-    reader.join(timeout=1)
-
-
 # --- OLED spectrum visualizer -----------------------------------------------
 # Taps the real audio the host is playing - PulseAudio's monitor source on
-# Linux, a BlackHole loopback device on macOS (see docs/PLATFORM_SUPPORT.md
-# for the one-time setup) - not a simulation, and streams it to the remote as
+# Linux - not a simulation, and streams it to the remote as
 # "VU:<16 comma-separated 0-63 levels>" at ~15fps. Needs numpy; anywhere else
-# (or without the capture source set up) this quietly no-ops and the remote
-# just shows its normal PLAY text screen.
+# (macOS can't capture system audio without a signed helper - see
+# docs/PLATFORM_SUPPORT.md) this quietly no-ops and the remote just shows its
+# normal PLAY text screen.
 VU_BARS = 16   # must match the firmware's VU_BARS
 VU_RATE_HZ = 15
 VU_SAMPLE_RATE = 22050
@@ -3386,55 +2891,19 @@ def _pulse_default_monitor():
     return f"{sink}.monitor" if sink else None
 
 
-def _darwin_blackhole_input():
-    """Index of the 'BlackHole' avfoundation audio device, or None if it's not
-    installed. macOS has no built-in loopback source - this requires the user
-    to `brew install blackhole-2ch` and set a Multi-Output Device (BlackHole +
-    real speakers) as the system's default output, so audio is both audible
-    and tapped (see docs/PLATFORM_SUPPORT.md)."""
-    try:
-        # Device list is on stderr; ffmpeg exits non-zero here, that's normal.
-        out = subprocess.run(["ffmpeg", "-f", "avfoundation", "-list_devices", "true", "-i", ""],
-                              capture_output=True, text=True, timeout=5).stderr
-    except Exception:
-        return None
-    in_audio = False
-    for line in out.splitlines():
-        if "AVFoundation audio devices" in line:
-            in_audio = True
-            continue
-        if in_audio:
-            m = re.search(r"\[(\d+)\]\s+(.*)", line)
-            if m and "blackhole" in m.group(2).lower():
-                return m.group(1)
-    return None
-
-
 def _vu_capture_cmd():
-    """subprocess argv that streams raw s16le mono PCM at VU_SAMPLE_RATE on
-    stdout for whatever's currently playing, or None if this OS/setup can't
-    do it. One capture source per platform; the FFT/scaling pipeline below is
-    the same regardless of where the bytes came from."""
-    system = discstation_host.system_name()
-    if system == "linux":
-        monitor = _pulse_default_monitor()
-        if not monitor:
-            return None
-        # --latency-msec=50: PulseAudio's default capture buffer is several
-        # hundred ms to seconds (tuned for robust recording, not streaming) -
-        # without this, parec hands us data in ~1.5-2s bursts instead of a
-        # steady trickle, which starves the visualizer for longer than the
-        # firmware's fallback timeout and flickers back to the text screen.
-        return ["parec", "--format=s16le", f"--rate={VU_SAMPLE_RATE}", "--channels=1",
-                "--latency-msec=50", "-d", monitor]
-    if system == "darwin":
-        idx = _darwin_blackhole_input()
-        if idx is None:
-            return None
-        return ["ffmpeg", "-f", "avfoundation", "-i", f":{idx}",
-                "-ac", "1", "-ar", str(VU_SAMPLE_RATE), "-f", "s16le",
-                "-loglevel", "error", "-"]
-    return None
+    """parec argv streaming raw s16le mono PCM at VU_SAMPLE_RATE from the
+    default sink's monitor, or None if PulseAudio has no default sink."""
+    monitor = _pulse_default_monitor()
+    if not monitor:
+        return None
+    # --latency-msec=50: PulseAudio's default capture buffer is several
+    # hundred ms to seconds (tuned for robust recording, not streaming) -
+    # without this, parec hands us data in ~1.5-2s bursts instead of a
+    # steady trickle, which starves the visualizer for longer than the
+    # firmware's fallback timeout and flickers back to the text screen.
+    return ["parec", "--format=s16le", f"--rate={VU_SAMPLE_RATE}", "--channels=1",
+            "--latency-msec=50", "-d", monitor]
 
 
 def _vu_loop(ser, stop_event, pause_event):
@@ -3494,11 +2963,9 @@ def _vu_loop(ser, stop_event, pause_event):
 
 def start_vu_visualizer(ser):
     """Best-effort: returns (stop_event, pause_event), or (None, None) if the
-    visualizer can't run here (no numpy, no capture source, or a web-only
-    link). Linux (PulseAudio) and macOS (BlackHole, see
-    docs/PLATFORM_SUPPORT.md) only - _vu_capture_cmd() returns None anywhere
-    else, or if the OS-specific capture device isn't set up."""
-    if _np is None or isinstance(ser, VirtualSerial) or discstation_host.system_name() not in ("linux", "darwin"):
+    visualizer can't run here (no numpy, no PulseAudio, or a web-only link).
+    Linux only."""
+    if _np is None or isinstance(ser, VirtualSerial) or discstation_host.system_name() != "linux":
         return None, None
     stop_event = threading.Event()
     pause_event = threading.Event()
@@ -3551,7 +3018,7 @@ def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None, s
     # floods journald until the pipe backs up and our own print()/status
     # writes block, wedging the whole play loop. We drive mpv over the IPC
     # socket, so none of that output is wanted.
-    proc = subprocess.Popen(run_as_desktop_user(cmd), env=env,
+    proc = subprocess.Popen(cmd, env=env,
                             stdin=(stdin_proc.stdout if stdin_proc else None),
                             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
     if stdin_proc:
@@ -3721,16 +3188,7 @@ def _play_audio_cd_windows(ser, device, track_titles):
     cmd, kwargs = discstation_host.ps_cmd("play-audio-cd.ps1", device, str(cmd_file))
     proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, **kwargs)
 
-    lines = Queue()
-
-    def read_output():
-        try:
-            for line in proc.stdout:
-                lines.put(line.rstrip("\r\n"))
-        finally:
-            lines.put(None)
-
-    threading.Thread(target=read_output, daemon=True).start()
+    lines, eof = discstation_burn.proc_line_queue(proc)
 
     def send_cmd(text):
         cmd_file.write_text(text + "\n")
@@ -3753,6 +3211,8 @@ def _play_audio_cd_windows(ser, device, track_titles):
                 line = lines.get(timeout=0.1)
             except Empty:
                 line = None
+            if line is eof:
+                line = None
             if line:
                 if line.startswith("TRACK:"):
                     try:
@@ -4099,12 +3559,12 @@ def handbrake_rip_main_feature(ser, device, out_dir, title_index):
     return dest
 
 
-def rip_flow(ser, artist_hint=None, album_hint=None):
+def rip_flow(ser):
     device = discstation_burn.disc_device()
     kind = disc_kind(device)
 
     if kind == "audio_cd":
-        rip_audio_cd(ser, device, artist_hint, album_hint)
+        rip_audio_cd(ser, device)
         return
 
     if kind in ("vcd", "svcd", "video_data"):
@@ -4162,7 +3622,6 @@ def rip_flow(ser, artist_hint=None, album_hint=None):
         safe_send(ser, "DONE:Rip complete!")
         print(f"Rip complete: {out_dir}")
         out_dir = _finalize_video_rip(ser, out_dir, device, "dvd_video")
-        chown_to_sudo_user(out_dir)
         time.sleep(3)
         return
 
@@ -4187,7 +3646,6 @@ def rip_flow(ser, artist_hint=None, album_hint=None):
         safe_send(ser, "DONE:Rip complete!")
         print(f"Rip complete: {out_dir}")
         out_dir = _finalize_video_rip(ser, out_dir, device, "dvd_video")
-        chown_to_sudo_user(out_dir)
         time.sleep(3)
         return
 
@@ -4237,7 +3695,7 @@ def rip_flow(ser, artist_hint=None, album_hint=None):
         raise
 
     if proc.wait() != 0:
-        if not disc_present(device):
+        if drive_status(device) in ("open", "no_disc"):
             raise RuntimeError("Disc was removed during rip")
         raise RuntimeError("Rip failed")
 
@@ -4245,7 +3703,6 @@ def rip_flow(ser, artist_hint=None, album_hint=None):
     safe_send(ser, "DONE:Rip complete!")
     print(f"Rip complete: {out_dir}")
     out_dir = _finalize_video_rip(ser, out_dir, device, "dvd_video")
-    chown_to_sudo_user(out_dir)
     time.sleep(3)
 
 
@@ -4285,7 +3742,6 @@ def rip_video_disc(ser, device, kind):
     safe_send(ser, "DONE:Rip complete!")
     print(f"Video rip complete: {out_dir}")
     out_dir = _finalize_video_rip(ser, out_dir, device, kind)
-    chown_to_sudo_user(out_dir)
     time.sleep(3)
 
 
@@ -4316,7 +3772,7 @@ def _rip_audio_cd_macos(ser, device, chapters, metadata, cover_path, out_dir):
     )
     output = []
     try:
-        for line in _iter_proc_lines(proc, ser):
+        for line in discstation_burn.iter_proc_or_cancel(proc, ser):
             output.append(line)
             count = len(list(wav_dir.glob("*.wav")))
             if count:
@@ -4360,18 +3816,17 @@ def _rip_audio_cd_macos(ser, device, chapters, metadata, cover_path, out_dir):
     shutil.rmtree(str(wav_dir), ignore_errors=True)
     safe_send(ser, "PROGRESS:100%")
     safe_send(ser, "DONE:Rip complete!")
-    chown_to_sudo_user(out_dir)
     time.sleep(3)
 
 
-def rip_audio_cd(ser, device, artist_hint=None, album_hint=None):
+def rip_audio_cd(ser, device):
     chapters = audio_cd_chapters(device)
     metadata = None
     cover_path = None
 
     _raise_if_cancelled(ser)
     send(ser, "STATUS:Looking up CD...")
-    metadata = audio_metadata_lookup(device, len(chapters), artist_hint, album_hint)
+    metadata = audio_metadata_lookup(device, len(chapters))
     _raise_if_cancelled(ser)
 
     if metadata:
@@ -4447,7 +3902,7 @@ def rip_audio_cd(ser, device, artist_hint=None, album_hint=None):
     )
 
     try:
-        for line in _iter_proc_lines(proc, ser):
+        for line in discstation_burn.iter_proc_or_cancel(proc, ser):
             print(line, end="")
             secs = parse_ffmpeg_time(line)
             if secs is not None and rip_duration > 0:
@@ -4464,7 +3919,7 @@ def rip_audio_cd(ser, device, artist_hint=None, album_hint=None):
         safe_send(ser, "CANCELLED:Rip cancelled")
         return
     elif proc.returncode != 0:
-        if not disc_present(device):
+        if drive_status(device) in ("open", "no_disc"):
             raise RuntimeError("Disc was removed during rip")
         raise RuntimeError("Audio CD rip failed")
 
@@ -4500,11 +3955,10 @@ def rip_audio_cd(ser, device, artist_hint=None, album_hint=None):
     safe_send(ser, "PROGRESS:100%")
     safe_send(ser, "DONE:Rip complete!")
     print(f"Audio rip complete: {out_dir}")
-    chown_to_sudo_user(out_dir)
     time.sleep(3)
 
 
-def station_loop(ser, url, artist_hint=None, album_hint=None):
+def station_loop(ser):
     global _last_burn_result, _last_burn_result_time, _tray_open, _tray_open_since, _operation_active, _web_op_verb
     discstation_burn.cleanup_old_jobs()
     try:
@@ -4748,16 +4202,13 @@ def station_loop(ser, url, artist_hint=None, album_hint=None):
         _operation_active = True  # stop /disc-info probing the drive during the flow
         try:
             if mode == "BURN":
-                burn_flow(ser, url)
+                burn_flow(ser)
                 _last_burn_result = "Burn complete"
             elif mode == "PLAY":
                 play_flow(ser)
             elif mode == "RIP":
-                rip_flow(ser, artist_hint, album_hint)
+                rip_flow(ser)
                 _last_burn_result = "Rip complete"
-            elif mode == "BURN MPG":
-                burn_mpg_flow(ser)
-                _last_burn_result = "Burn complete"
             elif mode == "BURN DATA":
                 burn_data_flow(ser)
                 _last_burn_result = "Burn complete"
@@ -4825,15 +4276,7 @@ def check_pidfile():
 
 def parse_args():
     parser = argparse.ArgumentParser(description="Physical DVD station controller")
-    parser.add_argument("--artist", help="Audio CD album artist hint for metadata fallback")
-    parser.add_argument("--album", help="Audio CD album title hint for metadata fallback")
-    parser.add_argument(
-        "--retag-latest-audio",
-        action="store_true",
-        help="Retag the newest generic audio_cd_* rip using --artist/--album, then exit",
-    )
     parser.add_argument("--port", type=int, default=8080, help="Web interface port")
-    parser.add_argument("url", nargs="?", help="YouTube URL or file path for burn mode")
     return parser.parse_args()
 
 
@@ -4847,15 +4290,6 @@ def main():
     exit_code = 0
 
     try:
-        if args.retag_latest_audio:
-            rip_dir = latest_audio_rip_dir()
-            new_dir, cover_path, renamed = retag_audio_rip(rip_dir, args.artist, args.album)
-            print(f"Retagged: {new_dir}")
-            print(f"Cover: {cover_path or 'not found'}")
-            for path in renamed:
-                print(path.name)
-            return
-
         start_web_server(args.port)
 
         while True:
@@ -4901,7 +4335,7 @@ def main():
                 # one now so a connected web remote learns about a newly-attached
                 # ESP32 immediately instead of only on its next reload.
                 _sse_publish(_status_snapshot())
-                station_loop(ser, args.url, args.artist, args.album)
+                station_loop(ser)
             except _HardwareAttached:
                 print("ESP32 detected - handing off from the web remote to hardware.")
             except (serial.SerialException, OSError, termios.error) as e: