discstation 0.1.34 → 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
@@ -59,6 +57,7 @@ _web_status = "READY"
 _web_progress = -1
 _web_progress_active = False
 _web_playing = False  # a play_flow is currently active (transport controls apply)
+_web_op_verb = "BURNING"  # progress-bar verb for the current PROGRESS: stream
 _operation_active = False  # a burn/rip/play flow is holding the drive
 _last_disc_info = {"disc_present": False, "capacity_bytes": 0, "capacity_gb": 0, "type": "none"}
 _active_ser = None
@@ -85,6 +84,14 @@ class VirtualSerial:
         with self._lock:
             self._buf += text.encode(errors="ignore").strip() + b"\n"
 
+    def clear(self):
+        """Drop any unconsumed input - used when a fresh SELECT: comes in so a
+        START that was queued for an abandoned earlier selection (the web
+        remote's mode buttons queue it right behind SELECT: so a one-click
+        burn works) can't leak forward and fire a different, unintended burn."""
+        with self._lock:
+            self._buf = b""
+
     @property
     def in_waiting(self):
         with self._lock:
@@ -296,7 +303,14 @@ class _WebHandler(http.server.BaseHTTPRequestHandler):
         _burn_url_queue.put(str(upload_dir))
         size_str = f"{total / 1e6:.1f}MB" if total > 1e6 else f"{total / 1e3:.0f}KB"
         _set_web_progress("UPLOAD READY", 100)
-        self._respond(200, f'{len(files)} file(s) uploaded ({size_str}). Select BURN DATA on remote.')
+        # Used to hardcode "Select BURN DATA on remote" - wrong mode name for
+        # an audio upload, and assumes hardware that may not exist. A mode
+        # may also already be selected (the one-click remote flow queues the
+        # burn before upload finishes), so this is just a status line, not
+        # an instruction to a specific next step.
+        tip = ("Select a mode on your remote." if _appliance_mode == "hardware"
+               else "Choose a burn mode below to start.")
+        self._respond(200, f'{len(files)} file(s) uploaded ({size_str}). {tip}')
 
     def _handle_remote_button(self):
         """Web on-screen remote -> the exact same text-line protocol the
@@ -319,7 +333,9 @@ class _WebHandler(http.server.BaseHTTPRequestHandler):
     def _serve_disc_info(self):
         if _operation_active:
             # a burn/rip/play holds the drive — don't probe it, serve last-known.
-            self._respond(200, json.dumps({**_last_disc_info, "busy": True, "appliance": _appliance_mode}), "application/json")
+            # menu_items empty: don't invite starting a second op on top of
+            # the one already running (CANCEL/EJECT stay available regardless).
+            self._respond(200, json.dumps({**_last_disc_info, "busy": True, "menu_items": [], "appliance": _appliance_mode}), "application/json")
             return
         info = {"disc_present": False, "capacity_bytes": 0, "capacity_gb": 0, "type": "none"}
         try:
@@ -336,6 +352,7 @@ class _WebHandler(http.server.BaseHTTPRequestHandler):
                 info["type"] = di.web_type
             info["kind"] = di.kind
             info["label"] = di.label
+            info["menu_items"] = menu_items_for_disc(device) if di.present and not di.transient else []
         except Exception as e:
             print(f"Disc info error: {e}")
         info["appliance"] = _appliance_mode
@@ -564,14 +581,13 @@ def start_web_server(port=8080):
 
 
 def local_ip():
-    try:
-        result = subprocess.run(['hostname', '-I'], capture_output=True, text=True, timeout=2)
-        ips = result.stdout.strip().split()
-        for ip in ips:
-            if ip.count('.') == 3 and not ip.startswith('127.'):
-                return ip
-    except Exception:
-        pass
+    # `hostname -I`'s first non-loopback address used to be the shortcut here,
+    # but it lists every interface with no notion of "the real one" - once
+    # Docker's docker0/br-* bridges (172.17/18.x, unreachable from outside
+    # this machine) exist, they can sort before the actual LAN NIC and get
+    # picked instead, showing a dead URL on the OLED/web remote. Asking the
+    # kernel what source address it'd use to reach the outside world sidesteps
+    # that entirely - Docker's bridges aren't in that route, no filtering needed.
     s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
     try:
         s.connect(('8.8.8.8', 80))
@@ -758,7 +774,7 @@ def _record_web_status(msg):
         _web_progress_active = True
     elif msg.startswith("PROGRESS:"):
         value = msg[9:].strip()
-        _web_status = f"BURNING {value}"
+        _web_status = f"{_web_op_verb} {value}"
         match = re.search(r"(\d+(?:\.\d+)?)", value)
         if match:
             _web_progress = min(100, max(0, int(float(match.group(1)))))
@@ -801,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."""
@@ -918,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:
@@ -973,7 +942,16 @@ def check_serial_alive(ser=None):
     """Raise serial.SerialException if the ESP32 link looks dead, so main()'s
     reconnect loop can re-scan for the (possibly renumbered) serial port.
     Call this inside any long poll loop that would otherwise spin forever on a
-    stale handle (writes to a re-enumerated /dev/ttyUSBN fail silently)."""
+    stale handle (writes to a re-enumerated /dev/ttyUSBN fail silently).
+
+    Meaningless (and actively harmful) in pure web/software mode - there's no
+    ESP32 to go quiet, and serial_activity_age() only advances on real
+    incoming bytes, so a user just reading the screen for >35s before
+    clicking the next button on the web remote looked identical to a dead
+    link and killed the burn ("ESP32 not responding") with no ESP32 in the
+    picture at all."""
+    if isinstance(ser, VirtualSerial):
+        return
     if discstation_burn.serial_write_failed():
         raise serial.SerialException("serial write failed (ESP32 link lost)")
     if discstation_burn.serial_activity_age() >= 35:
@@ -1048,10 +1026,16 @@ def eject_disc(ser, device):
         _tray_open = True
         _tray_open_since = time.monotonic()
         safe_send(ser, "WAITING:Press SELECT/to close tray")
+        # WAITING: isn't in _record_web_status()'s prefix whitelist, so the
+        # send above never reaches the web page - _tray_open has to be
+        # published explicitly here, same as DISC: gets its own dedicated
+        # publish for the same reason.
+        _sse_publish(_status_snapshot())
         last_ping = time.time()
         deadline = time.time() + 60
         tray_was_cancelled = False
         last_status_check = 0
+        closed_confirms = 0
         # Let the eject settle before touching the drive again (the reclose guard).
         settle_until = time.time() + 3
         while time.time() < deadline:
@@ -1061,9 +1045,20 @@ def eject_disc(ser, device):
             if time.time() >= settle_until and time.time() - last_status_check >= 1.5:
                 last_status_check = time.time()
                 if drive_status(device) in ("disc", "no_disc"):
-                    print("Tray closed — continuing")
-                    _tray_open = False
-                    break
+                    # This USB-ATAPI bridge's status reporting is known flaky
+                    # (see udev_cdrom_properties' own docstring) - one read
+                    # right after an eject was seen live to falsely report
+                    # closed, reclosing the wait loop within ~11s of a real
+                    # eject. Require two consecutive agreeing reads before
+                    # believing it.
+                    closed_confirms += 1
+                    if closed_confirms >= 2:
+                        print("Tray closed — continuing")
+                        _tray_open = False
+                        _sse_publish(_status_snapshot())
+                        break
+                else:
+                    closed_confirms = 0
             line = read_serial_line(ser, timeout=0.1)
             if not line:
                 continue
@@ -1080,6 +1075,7 @@ def eject_disc(ser, device):
                         r = subprocess.run(close_cmd, timeout=10, capture_output=True)
                         if r.returncode == 0:
                             _tray_open = False
+                            _sse_publish(_status_snapshot())
                             break
                     except Exception:
                         pass
@@ -1129,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(
@@ -1248,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
@@ -1863,10 +1866,13 @@ def menu_items_for_disc(device):
     kind = disc_kind(device)
     items = []
     if kind == "blank" or is_rewritable_disc(device):
-        items = ["BURN", "BURN DATA", "BURN AUDIO"]
-        had = discstation_burn.WORK.rglob("movie.mpg")
-        if any(True for _ in had):
-            items.append("BURN MPG")
+        # CD-R/RW can't hold a DVD-video authoring job (nowhere near the
+        # space) and DVD blanks can't take Red Book audio (wrong format
+        # entirely, would just fail) - offer only what's physically possible
+        # for the media that's actually in the drive.
+        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"]
     elif kind in ("dvd_video", "audio_cd", "vcd", "svcd", "video_data", "data_disc", "data_cd"):
         items = ["PLAY", "RIP"]
     else:
@@ -2166,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(
@@ -2226,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))
 
@@ -2410,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):
@@ -2423,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(
@@ -2548,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:
@@ -2617,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:
@@ -2666,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):
@@ -2700,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)
@@ -2786,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)
@@ -2834,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())
@@ -2964,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)
@@ -3011,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")
@@ -3036,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]
@@ -3079,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():
@@ -3210,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):
@@ -3229,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
@@ -3335,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):
@@ -3443,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()
@@ -3500,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:
@@ -3524,6 +3042,10 @@ def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None, s
         current_volume = None
         current_track = None
         last_track_poll = 0
+        # Set to "eject" below when EJECT (not PLAY_STOP/CANCEL/HOME) is what
+        # ended playback - returned to the caller so it can actually eject
+        # the tray afterward, not just return to the menu.
+        stop_reason = None
         track_titles = track_titles or []
         track_starts = track_starts or []
         send(ser, "PLAY_MODE:AUDIO_CD" if kind == "audio_cd" else "PLAY_MODE:DEFAULT")
@@ -3566,12 +3088,18 @@ def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None, s
                         vu_pause.set() if paused else vu_pause.clear()
                     send(ser, "PLAY_STATUS:PAUSED" if paused else "PLAY_STATUS:PLAYING")
 
-                elif line in ("PLAY_STOP", "EJECT"):
-                    # EJECT during playback = stop first; the web remote has no
-                    # separate stop button, and without this the command is
-                    # silently dropped here and playback never ends.
+                elif line in ("PLAY_STOP", "EJECT", "CANCEL", "HOME"):
+                    # All four end playback - EJECT alone also pops the tray
+                    # afterward (the web remote has its own dedicated STOP
+                    # button now, so EJECT no longer needs to double as one -
+                    # a user pressing eject while music plays wants the disc
+                    # out, not just silence). CANCEL/HOME return to the menu
+                    # exactly like they do everywhere else - previously
+                    # unhandled here, so they were silently dropped mid-play.
                     send(ser, "STATUS:Stopping play")
                     discstation_burn.stop_process(proc)
+                    if line == "EJECT":
+                        stop_reason = "eject"
                     break
 
                 elif line == "FF:BIG":
@@ -3646,6 +3174,7 @@ def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None, s
             os.unlink(MPV_SOCKET)
         except OSError:
             pass
+    return stop_reason
 
 
 def _play_audio_cd_windows(ser, device, track_titles):
@@ -3659,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")
@@ -3691,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:
@@ -3766,7 +3288,12 @@ def play_flow(ser):
         except FileNotFoundError:
             raise RuntimeError("mpv not found")
 
+    # "eject" once a play loop reports EJECT ended it (see _run_mpv) - acted
+    # on once, after the kind dispatch below, regardless of which branch ran.
+    stop_reason = None
+
     def play_vob_fallback():
+        nonlocal stop_reason
         # No DVD-menu engine available (libdvdnav missing, or on Windows
         # where the plain mpv build never has it) - play the main title's
         # VOBs directly off the mounted volume instead (no menus).
@@ -3786,7 +3313,7 @@ def play_flow(ser):
                 "--idle=no",
                 *[str(path) for path in files],
             ]
-            _run_mpv(ser, cmd, "Playing DVD", kind)
+            stop_reason = _run_mpv(ser, cmd, "Playing DVD", kind)
 
     if kind == "dvd_video":
         if discstation_host.system_name() == "darwin":
@@ -3799,7 +3326,7 @@ def play_flow(ser):
                     "--dvd-device=" + rip_device(device),
                     "dvdnav://",
                 ]
-                _run_mpv(ser, cmd, "Playing DVD", kind)
+                stop_reason = _run_mpv(ser, cmd, "Playing DVD", kind)
             except RuntimeError:
                 # libdvdnav couldn't open the disc.
                 play_vob_fallback()
@@ -3845,7 +3372,7 @@ def play_flow(ser):
             if audio_device:
                 cmd.insert(1, "--audio-device=" + audio_device)
                 print(f"Audio CD output: {audio_device}")
-            _run_mpv(ser, cmd, "Playing audio CD", kind, track_titles, track_starts, stdin_proc=rip_proc)
+            stop_reason = _run_mpv(ser, cmd, "Playing audio CD", kind, track_titles, track_starts, stdin_proc=rip_proc)
         else:
             audio_device = discstation_host.audio_output_device()
             cmd = [
@@ -3860,7 +3387,7 @@ def play_flow(ser):
             if audio_device:
                 cmd.insert(1, "--audio-device=" + audio_device)
                 print(f"Audio CD output: {audio_device}")
-            _run_mpv(ser, cmd, "Playing audio CD", kind, track_titles, track_starts)
+            stop_reason = _run_mpv(ser, cmd, "Playing audio CD", kind, track_titles, track_starts)
 
     elif kind in ("vcd", "svcd", "video_data"):
         with mounted_disc(device) as mount_dir:
@@ -3874,11 +3401,23 @@ def play_flow(ser):
                 "--idle=no",
                 *[str(path) for path in files],
             ]
-            _run_mpv(ser, cmd, f"Playing {kind.upper()}", kind)
+            stop_reason = _run_mpv(ser, cmd, f"Playing {kind.upper()}", kind)
 
     else:
         raise RuntimeError(f"Unsupported disc: {kind}")
 
+    if stop_reason == "eject":
+        safe_send(ser, "STATUS:Ejecting...")
+        # mpv/cd-paranoia just got killed above - give the OS a moment to
+        # actually release the device handle before touching it again, or
+        # the primary `eject` command can hit "Device or resource busy" and
+        # fall back to the raw SCSI path, seen live to behave differently
+        # (the tray got marked closed again within ~11s of a real eject).
+        time.sleep(1)
+        try:
+            eject_disc(ser, device)
+        except Exception as e:
+            print(f"Eject after play failed: {e}")
     safe_send(ser, "DONE:Playback stopped")
     time.sleep(3)
 
@@ -4020,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"):
@@ -4083,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
 
@@ -4108,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
 
@@ -4158,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")
 
@@ -4166,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)
 
 
@@ -4206,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)
 
 
@@ -4237,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:
@@ -4281,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:
@@ -4368,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:
@@ -4385,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")
 
@@ -4421,12 +3955,11 @@ 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):
-    global _last_burn_result, _last_burn_result_time, _tray_open, _tray_open_since, _operation_active
+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:
         device = discstation_burn.disc_device()
@@ -4654,6 +4187,14 @@ def station_loop(ser, url, artist_hint=None, album_hint=None):
 
         mode = line.split(":", 1)[1].strip().upper()
         print(f"Selected: {mode}")
+        _web_op_verb = "RIPPING" if mode == "RIP" else "BURNING"
+        # The web remote's mode buttons queue START right behind SELECT: for a
+        # one-click burn (see app.js) - if an earlier selection was abandoned
+        # before its own START got consumed (e.g. never uploaded/confirmed a
+        # URL), that stale START would otherwise sit buffered and fire this
+        # new, different selection instead. Drop anything unconsumed first.
+        if isinstance(ser, VirtualSerial):
+            ser.clear()
 
         # The user picked a mode — they want to act on a disc, so the drive is
         # fair game again even if it was ejected from the OLED earlier.
@@ -4661,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"
@@ -4738,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()
 
 
@@ -4760,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:
@@ -4814,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: