discstation 0.1.33 → 0.1.35

package/README.md

@@ -141,11 +141,15 @@ self-signed cert. On startup the host prints the LAN URL to open
 - Upload files from any device on the LAN for data DVD burning
 - Submit YouTube URLs for video DVD burning
 - Dark theme, mobile-responsive, PWA (installable on phone)
-- **On-screen remote** — click the "REMOTE" tag next to the DiscStation
-  wordmark to reveal a full control surface (mode buttons, EJECT/CLOSE
-  toggle, live disc-status readout, playback transport). Fully functional
-  with no ESP32 attached; greys out and auto-collapses the instant a
-  physical remote is detected, so the two never fight for control.
+- **On-screen remote** — opens automatically with no ESP32 attached, since
+  it's the only control surface in that case (toggle it via the "REMOTE"
+  tag next to the wordmark any time). Mode buttons only show what the disc
+  in the drive can actually do — a blank CD offers BURN DATA/BURN AUDIO, a
+  blank DVD offers BURN/BURN DATA, an already-recorded disc offers PLAY/RIP
+  — and picking one starts it directly, no separate confirm step. Also has
+  EJECT/CLOSE toggle, a live disc-status readout, and full playback
+  transport. Greys out and auto-collapses the instant a physical remote is
+  detected, so the two never fight for control.
 
 ## Mobile App
 

package/install-macos.sh

@@ -50,7 +50,7 @@ if [[ -f "$ROOT_DIR/requirements-optional.txt" ]]; then
 fi
 
 DISC_DEVICE="${DISC_DEVICE:-}"
-DISC_PORT="${DISC_PORT:-$(ls /dev/cu.usbserial-* /dev/cu.usbmodem-* 2>/dev/null | head -1)}"
+DISC_PORT="${DISC_PORT:-$(ls /dev/cu.usbserial-* /dev/cu.usbmodem-* 2>/dev/null | head -1 || true)}"
 
 if [[ ! -f "$CONFIG_DIR/server.crt" || ! -f "$CONFIG_DIR/server.key" ]]; then
   openssl req -x509 -newkey rsa:2048 -nodes -days 3650 \

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discstation",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "description": "DiscStation optical-media appliance host — one cross-OS installer",
   "bin": {
     "discstation-setup": "scripts/setup.mjs",

package/src/discstation.py

@@ -59,6 +59,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 +86,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 +305,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 +335,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 +354,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 +583,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 +776,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)))))
@@ -973,7 +991,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 +1075,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 +1094,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 +1124,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
@@ -1863,7 +1908,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"]
+        # 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"]
         had = discstation_burn.WORK.rglob("movie.mpg")
         if any(True for _ in had):
             items.append("BURN MPG")
@@ -3524,6 +3575,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 +3621,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 +3707,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):
@@ -3766,7 +3828,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 +3853,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 +3866,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 +3912,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 +3927,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 +3941,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)
 
@@ -4426,7 +4505,7 @@ def rip_audio_cd(ser, device, artist_hint=None, album_hint=None):
 
 
 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
+    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 +4733,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.

package/src/discstation_burn.py

@@ -1567,30 +1567,27 @@ def burn_audio_cd(ser, audio_files, disc_label, speed=None):
 
     album_t = _cdt(album_title) or "Audio CD"
     album_p = _cdt(album_artist) or "Unknown Artist"
-    toc_lines = ["CD_DA"]
-    toc_lines.append("CD_TEXT {")
-    toc_lines.append("  LANGUAGE_MAP { 0: EN }")
-    toc_lines.append("  LANGUAGE 0 {")
-    toc_lines.append(f'    TITLE "{album_t}"')
-    toc_lines.append(f'    PERFORMER "{album_p}"')
-    toc_lines.append("  }")
-    toc_lines.append("}")
-    toc_lines.append("")
-    for i, (artist, title) in enumerate(track_meta):
-        wav = tmp_dir / f"track_{i + 1:02d}.wav"
-        track_t = _cdt(title) or f"Track {i + 1:02d}"
-        track_p = _cdt(artist) or album_p
-        toc_lines.append("TRACK AUDIO")
-        toc_lines.append("CD_TEXT {")
-        toc_lines.append("  LANGUAGE 0 {")
-        toc_lines.append(f'    TITLE "{track_t}"')
-        toc_lines.append(f'    PERFORMER "{track_p}"')
-        toc_lines.append("  }")
-        toc_lines.append("}")
-        toc_lines.append(f'FILE "{wav}" 0')
-        toc_lines.append("")
     toc_path = tmp_dir / "disc.toc"
-    toc_path.write_text("\n".join(toc_lines) + "\n")
+
+    def _write_toc(include_cdtext):
+        toc_lines = ["CD_DA"]
+        if include_cdtext:
+            toc_lines += ["CD_TEXT {", "  LANGUAGE_MAP { 0: EN }", "  LANGUAGE 0 {",
+                          f'    TITLE "{album_t}"', f'    PERFORMER "{album_p}"',
+                          "  }", "}", ""]
+        for i, (artist, title) in enumerate(track_meta):
+            wav = tmp_dir / f"track_{i + 1:02d}.wav"
+            toc_lines.append("TRACK AUDIO")
+            if include_cdtext:
+                track_t = _cdt(title) or f"Track {i + 1:02d}"
+                track_p = _cdt(artist) or album_p
+                toc_lines += ["CD_TEXT {", "  LANGUAGE 0 {", f'    TITLE "{track_t}"',
+                              f'    PERFORMER "{track_p}"', "  }", "}"]
+            toc_lines.append(f'FILE "{wav}" 0')
+            toc_lines.append("")
+        toc_path.write_text("\n".join(toc_lines) + "\n")
+
+    _write_toc(include_cdtext=True)
     print(f"CD-TEXT: album={album_t!r} performer={album_p!r}, "
           f"{len(track_meta)} track titles")
     send(ser, "PROGRESS:35%")
@@ -1607,9 +1604,8 @@ def burn_audio_cd(ser, audio_files, disc_label, speed=None):
         return
 
     send(ser, "STATUS:Burning audio CD...")
-    # The cooked generic-mmc writer does NOT lay down the CD-TEXT lead-in on most
-    # ATAPI drives; the raw writer does. Override with DISCSTATION_CDRDAO_DRIVER
-    # (set it empty to let cdrdao auto-pick).
+    # DISCSTATION_CDRDAO_DRIVER forces one specific driver (set it empty for
+    # cdrdao to auto-pick) instead of the try-in-order fallback below.
     try:
         cdrdao_write_dev = discstation_host.cdrdao_device(disc_device())
     except RuntimeError:
@@ -1617,39 +1613,71 @@ def burn_audio_cd(ser, audio_files, disc_label, speed=None):
             raise RuntimeError("Audio CD burning is not supported on this Mac "
                                "(cdrdao cannot access the optical drive)")
         raise
-    cdrdao_cmd = [tool('cdrdao'), 'write', '--buffers', '64',
-                  '--device', cdrdao_write_dev]
-    driver = os.environ.get("DISCSTATION_CDRDAO_DRIVER", "generic-mmc-raw")
-    if driver:
-        cdrdao_cmd += ['--driver', driver]
-    speed_ = speed or DISC_SPEED
-    if speed_ and speed_.lower() != "auto":
-        cdrdao_cmd += ['--speed', speed_.rstrip('x')]
-    cdrdao_cmd.append(str(toc_path))  # toc-file must come after all options
-
-    proc = subprocess.Popen(cdrdao_cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
-    out_lines = []
+    def _run_cdrdao(driver):
+        cmd = [tool('cdrdao'), 'write', '--buffers', '64', '--device', cdrdao_write_dev]
+        if driver:
+            cmd += ['--driver', driver]
+        speed_ = speed or DISC_SPEED
+        if speed_ and speed_.lower() != "auto":
+            cmd += ['--speed', speed_.rstrip('x')]
+        cmd.append(str(toc_path))  # toc-file must come after all options
+        proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+        lines = []
+        last_prog = 0
+        try:
+            for line in iter_proc_or_cancel(proc, ser):
+                lines.append(line)
+                # "Wrote 12 of 650 MB (Buffers 99%  100%)." is the real write
+                # progress - matching on the first bare NN% instead (as this
+                # used to) grabs the *buffer fill* percentage, which BURN-Proof
+                # holds near 100% for virtually the whole burn, so the OLED
+                # jumped straight from "Converting" to 100% and sat there.
+                m = re.search(r'Wrote\s+(\d+)\s+of\s+(\d+)\s+MB', line)
+                if m and int(m.group(2)) > 0:
+                    frac = int(m.group(1)) / int(m.group(2))
+                    pct = 35 + int(frac * 65)
+                    now = time.time()
+                    if now - last_prog >= 0.2:
+                        send(ser, f"PROGRESS:{pct}%")
+                        last_prog = now
+        except (KeyboardInterrupt, SystemExit):
+            stop_process(proc)
+            raise
+        return proc.wait(), lines
+
     log_path = WORK / "cdrdao.log"
-    last_prog = 0
+    override = os.environ.get("DISCSTATION_CDRDAO_DRIVER")
+    # generic-mmc-raw (raw P-W sub-channel writing) is what guarantees CD-TEXT,
+    # but some drives reject raw sub-channel writing outright - confirmed live
+    # on this drive with --simulate: it fails at the lead-in even with CD-TEXT
+    # stripped out entirely, so it's the raw *driver* that's incompatible here,
+    # not CD-TEXT itself. generic-mmc (cooked) writes fine on the same drive
+    # (also confirmed with --simulate) and still carries the CD-TEXT blocks in
+    # the TOC, so it's worth trying with labels intact before dropping them -
+    # only the last resort actually removes CD-TEXT from the TOC.
+    drivers_to_try = [override] if override else ["generic-mmc-raw", "generic-mmc"]
     try:
-        for line in iter_proc_or_cancel(proc, ser):
-            out_lines.append(line)
-            m = re.search(r'(\d+)\s*%', line)
-            if m:
-                pct = 35 + int(int(m.group(1)) * 0.65)
-                now = time.time()
-                if now - last_prog >= 0.2:
-                    send(ser, f"PROGRESS:{pct}%")
-                    last_prog = now
-    except (KeyboardInterrupt, SystemExit):
-        stop_process(proc)
-        raise
+        rc, out_lines = -1, []
+        for i, driver in enumerate(drivers_to_try):
+            if i > 0:
+                print(f"cdrdao: write failed with previous driver - retrying with --driver {driver or 'auto'}")
+                send(ser, "STATUS:Retrying burn...")
+            rc, lines = _run_cdrdao(driver)
+            out_lines += ([f"--- driver {driver or 'auto'} ---"] if i else []) + lines
+            if rc == 0 or rc == -15:
+                break
+        if rc != 0 and rc != -15 and not override:
+            print("cdrdao: all driver modes failed - retrying without CD-TEXT")
+            send(ser, "STATUS:Retrying without CD-TEXT...")
+            _write_toc(include_cdtext=False)
+            rc2, lines2 = _run_cdrdao(None)
+            out_lines += ["--- retry without CD-TEXT ---"] + lines2
+            rc = rc2
     finally:
         for w in tmp_dir.glob("*.wav"):
             w.unlink(missing_ok=True)
         toc_path.unlink(missing_ok=True)
         shutil.rmtree(str(tmp_dir), ignore_errors=True)
-    rc = proc.wait()
     log_path.write_text("\n".join(out_lines) + "\n")
     if rc != 0:
         for line in out_lines[-10:]:

package/src/static/app.js

@@ -92,6 +92,10 @@
   function applyRemoteState(progress) {
     const hardware = progress.appliance === "hardware";
     if (hardware && !$("remote-panel").hidden) setRemoteVisible(false, true);
+    // Software mode has no other control surface at all - don't make it
+    // opt-in-via-logo-click to discover the only way to actually use the
+    // appliance. Only forces it open (never closes it back on the user).
+    if (!hardware && $("remote-panel").hidden) setRemoteVisible(true, true);
     $("remote-note").textContent = hardware
       ? "A physical remote is attached — on-screen controls are disabled."
       : "No physical remote detected — control DiscStation from here.";
@@ -119,9 +123,20 @@
   });
   setRemoteVisible(localStorage.getItem(remoteKey) === "1");
 
-  $("remote-controls").addEventListener("click", (event) => {
+  $("remote-controls").addEventListener("click", async (event) => {
     const button = event.target.closest("[data-cmd]");
-    if (button && !button.disabled) sendRemoteCmd(button.dataset.cmd);
+    if (!button || button.disabled) return;
+    const cmd = button.dataset.cmd;
+    await sendRemoteCmd(cmd);
+    // On real hardware START is a long-press of the encoder on the burn-ready
+    // review screen, not its own button - a one-click "BURN AUDIO"/"BURN
+    // DATA"/"BURN" here is the whole point of the web remote, so chase the
+    // mode select straight through to starting the burn instead of leaving
+    // the user stuck with nothing left to press. (The backend queues this
+    // harmlessly if files/URL aren't in yet - it's only consumed once the
+    // burn's actually at its own "waiting for start" step, and gets flushed
+    // if a different mode gets selected first so it can't fire the wrong burn.)
+    if (cmd.startsWith("SELECT:BURN")) await sendRemoteCmd("START");
   });
   let volumeTimer;
   $("remote-volume").addEventListener("input", (event) => {
@@ -130,11 +145,25 @@
     volumeTimer = setTimeout(() => sendRemoteCmd(`POT:${value}`), 150);
   });
 
+  // Mode-select buttons this server-computed list governs - CANCEL/EJECT are
+  // controls, not modes, and stay available regardless (same as hardware).
+  const MENU_MODES = ["BURN", "BURN DATA", "BURN AUDIO", "RIP", "PLAY"];
+
+  function applyMenuItems(items) {
+    if (!items) return;                    // unknown (fetch error, etc.) - leave as-is
+    const allowed = new Set(items);
+    MENU_MODES.forEach((mode) => {
+      const btn = document.querySelector(`#remote-controls [data-cmd="SELECT:${mode}"]`);
+      if (btn) btn.hidden = !allowed.has(mode);
+    });
+  }
+
   async function loadDiscInfo() {
     try {
       const response = await fetch("/disc-info", { cache: "no-store" });
       const info = await response.json();
       renderDiscStatus(info);
+      applyMenuItems(info.menu_items);
       if (info.busy) return;               // burn/rip in progress — keep current
       state.discBytes = Number(info.capacity_bytes || 0);
       state.discType = info.type || "none";
@@ -150,7 +179,7 @@
     const el = $("remote-disc-status");
     if (!el) return;
     if (!info) { el.textContent = "DISC: UNKNOWN"; return; }
-    if (info.busy) { el.textContent = "DISC: BUSY (see status above)"; return; }
+    if (info.busy) { el.textContent = "DISC: BUSY"; return; }
     if (!info.disc_present) { el.textContent = "DISC: NONE"; return; }
     const kind = (info.type || info.kind || "unknown").toUpperCase();
     const label = info.label ? ` "${info.label}"` : "";