discstation 0.1.20 → 0.1.22

package/src/discstation.py

@@ -54,17 +54,71 @@ _web_port = 8080
 _web_server = None
 _last_burn_result = None
 _last_burn_result_time = 0
-_last_upload_dir = None
 _last_upload_label = None
 _web_status = "READY"
 _web_progress = -1
 _web_progress_active = False
+_web_playing = False  # a play_flow is currently active (transport controls apply)
 _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
+_appliance_mode = "hardware"  # "hardware" (real ESP32) or "software" (web remote only)
 STATIC_DIR = Path(__file__).resolve().parent / "static"
 
 
+class VirtualSerial:
+    """Drop-in stand-in for serial.Serial when no ESP32 is attached, so
+    station_loop and every flow function (burn/rip/play) run completely
+    unchanged - fed by lines POSTed to /remote/button instead of real
+    serial bytes. send()/safe_send() already publish every status update
+    through status_sink (-> the web SSE stream) regardless of ser, and
+    already tolerate ser=None, so only the "commands in" direction needs
+    shimming here - the exact same text protocol the ESP32 already speaks
+    (SELECT:..., PLAY_BUTTON, FF:BIG, CANCEL, POT:<n>, ...) is the contract,
+    so the on-screen remote just POSTs the same strings the ESP32 sends."""
+
+    def __init__(self):
+        self._buf = b""
+        self._lock = threading.Lock()
+
+    def push_line(self, text):
+        with self._lock:
+            self._buf += text.encode(errors="ignore").strip() + b"\n"
+
+    @property
+    def in_waiting(self):
+        with self._lock:
+            return len(self._buf)
+
+    def read(self, n=1):
+        with self._lock:
+            data, self._buf = self._buf[:n], self._buf[n:]
+            return data
+
+    def readline(self):
+        with self._lock:
+            idx = self._buf.find(b"\n")
+            if idx < 0:
+                data, self._buf = self._buf, b""
+                return data
+            line, self._buf = self._buf[:idx + 1], self._buf[idx + 1:]
+            return line
+
+    def write(self, data):
+        return len(data) if data else 0
+
+    def close(self):
+        pass
+
+    def setDTR(self, value):
+        pass
+
+
+class _HardwareAttached(Exception):
+    """Raised out of station_loop when a real ESP32 appears while running on
+    a VirtualSerial, so main() can hand control over to it."""
+
+
 class _WebHandler(http.server.BaseHTTPRequestHandler):
     def do_GET(self):
         path = urllib.parse.urlsplit(self.path).path
@@ -74,11 +128,7 @@ class _WebHandler(http.server.BaseHTTPRequestHandler):
             result = _last_burn_result
             self._respond(200, _web_status or result or 'Idle')
         elif path == '/progress':
-            self._respond(200, json.dumps({
-                "status": _web_status or "READY",
-                "progress": _web_progress,
-                "active": _web_progress_active,
-            }), "application/json")
+            self._respond(200, json.dumps(_status_snapshot()), "application/json")
         elif path == '/disc-info':
             self._serve_disc_info()
         elif path == '/events':
@@ -102,6 +152,8 @@ class _WebHandler(http.server.BaseHTTPRequestHandler):
                 self._handle_url()
         elif path == '/set-label':
             self._handle_set_label()
+        elif path == '/remote/button':
+            self._handle_remote_button()
         else:
             self.send_error(404)
 
@@ -117,7 +169,6 @@ class _WebHandler(http.server.BaseHTTPRequestHandler):
             self._respond(400, 'Missing URL')
 
     def _handle_upload(self):
-        global _last_upload_dir
         _set_web_progress("UPLOADING", 0)
         files = self._parse_multipart(lambda percent: _set_web_progress("UPLOADING", percent))
         if not files:
@@ -148,15 +199,42 @@ class _WebHandler(http.server.BaseHTTPRequestHandler):
             dest.parent.mkdir(parents=True, exist_ok=True)
             dest.write_bytes(data)
             total += len(data)
-        _last_upload_dir = str(upload_dir)
+        # wait_for_web_url() (already running on the OLED side once a burn
+        # mode is selected first - the normal flow: scan the QR code, then
+        # upload) only ever reads from _burn_url_queue, same as a pasted
+        # URL - this is the one and only signal an upload sends. (A second,
+        # separate _last_upload_dir global used to exist alongside this;
+        # removed - having two mechanisms for the same event meant one
+        # could consume its half while the other's copy sat undrained in
+        # the queue forever, waiting to wrongly satisfy a later, unrelated
+        # burn attempt.)
+        _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.')
 
+    def _handle_remote_button(self):
+        """Web on-screen remote -> the exact same text-line protocol the
+        ESP32 already speaks (SELECT:BURN DATA, PLAY_BUTTON, FF:BIG, CANCEL,
+        POT:<n>, ...), fed straight into the active VirtualSerial. Only
+        works in software mode - a real ESP32 already owns the input side."""
+        length = int(self.headers.get('Content-Length', 0))
+        body = self.rfile.read(length).decode()
+        params = urllib.parse.parse_qs(body)
+        cmd = params.get('cmd', [''])[0].strip()
+        if not cmd:
+            self._respond(400, 'Missing cmd')
+            return
+        if isinstance(_active_ser, VirtualSerial):
+            _active_ser.push_line(cmd)
+            self._respond(200, 'OK')
+        else:
+            self._respond(409, 'A hardware remote is attached')
+
     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}), "application/json")
+            self._respond(200, json.dumps({**_last_disc_info, "busy": True, "appliance": _appliance_mode}), "application/json")
             return
         info = {"disc_present": False, "capacity_bytes": 0, "capacity_gb": 0, "type": "none"}
         try:
@@ -175,6 +253,7 @@ class _WebHandler(http.server.BaseHTTPRequestHandler):
             info["label"] = di.label
         except Exception as e:
             print(f"Disc info error: {e}")
+        info["appliance"] = _appliance_mode
         _last_disc_info.update(info)
         self._respond(200, json.dumps(info), "application/json")
 
@@ -225,7 +304,7 @@ class _WebHandler(http.server.BaseHTTPRequestHandler):
     def _serve_sw(self):
         sw = '''self.addEventListener('install', e => {
   self.skipWaiting();
-  caches.open('discstation-v8').then(c => c.addAll(['/','/static/style.css?v=8','/static/app.js?v=8']));
+  caches.open('discstation-v17').then(c => c.addAll(['/','/static/style.css?v=17','/static/app.js?v=17']));
 });
 self.addEventListener('activate', e => e.waitUntil(clients.claim()));
 self.addEventListener('fetch', e => {
@@ -234,7 +313,7 @@ self.addEventListener('fetch', e => {
   if (path === '/' || path.startsWith('/static/')) {
     e.respondWith(fetch(e.request).then(r => {
       const copy = r.clone();
-      caches.open('discstation-v8').then(c => c.put(e.request, copy));
+      caches.open('discstation-v17').then(c => c.put(e.request, copy));
       return r;
     }).catch(() => caches.match(e.request)));
   } else {
@@ -377,6 +456,7 @@ def start_web_server(port=8080):
         http_port = int(os.environ.get("DISCSTATION_HTTP_PORT", "8081"))
     except ValueError:
         http_port = 8081
+    plain_http_up = False
     if http_port and http_port != port:
         try:
             plain = socketserver.ThreadingTCPServer(('', http_port), _WebHandler, bind_and_activate=False)
@@ -386,9 +466,15 @@ def start_web_server(port=8080):
             plain.server_activate()
             threading.Thread(target=plain.serve_forever, daemon=True).start()
             print(f"Plain HTTP (mobile app) on http://0.0.0.0:{http_port}")
+            plain_http_up = True
         except OSError as e:
             print(f"Plain HTTP listener not started on {http_port}: {e}")
 
+    ip = local_ip()
+    https_up = ssl is not None and cert.exists() and key.exists()
+    shown_port, shown_protocol = (http_port, "http") if plain_http_up else (port, "https" if https_up else "http")
+    print(f"\n>>> Open {shown_protocol}://{ip}:{shown_port} in your browser or the DiscStation app <<<\n")
+
     return server
 
 
@@ -539,7 +625,9 @@ _sse_lock = threading.Lock()
 
 
 def _status_snapshot():
-    return {"status": _web_status or "READY", "progress": _web_progress, "active": _web_progress_active}
+    return {"status": _web_status or "READY", "progress": _web_progress,
+            "active": _web_progress_active, "appliance": _appliance_mode,
+            "playing": _web_playing, "tray_open": _tray_open}
 
 
 def _sse_publish(event):
@@ -565,11 +653,17 @@ def _set_web_progress(phase, percent=-1):
 
 
 def _record_web_status(msg):
-    global _web_status, _web_progress, _web_progress_active
+    global _web_status, _web_progress, _web_progress_active, _web_playing
     if msg.startswith("DISC:"):
         _sse_publish({"type": "disc-changed"})
         return
-    if msg.startswith("STATUS:"):
+    if msg.startswith("PLAY_MODE:"):
+        _web_playing = True
+        _web_status = "PLAYING"
+        _web_progress_active = True
+    elif msg.startswith("PLAY_STATUS:") or msg.startswith("PLAY:"):
+        _web_status = msg.split(":", 1)[1].strip() or "PLAYING"
+    elif msg.startswith("STATUS:"):
         _web_status = msg[7:].strip() or "READY"
         _web_progress_active = True
     elif msg.startswith("PROGRESS:"):
@@ -583,12 +677,15 @@ def _record_web_status(msg):
         _web_status = msg[5:].strip() or "DONE"
         _web_progress = 100
         _web_progress_active = False
+        _web_playing = False
     elif msg.startswith("ERROR:"):
         _web_status = msg[6:].strip() or "ERROR"
         _web_progress_active = False
+        _web_playing = False
     elif msg.startswith("CANCELLED:"):
         _web_status = msg[10:].strip() or "CANCELLED"
         _web_progress_active = False
+        _web_playing = False
     elif msg.startswith(("STANDBY:", "HOME:")):
         # idle again (tray open, insert disc, back to the menu) — clear any
         # lingering "Ejecting..." / progress state on the web UI.
@@ -596,6 +693,7 @@ def _record_web_status(msg):
         _web_status = "READY" if text in ("", "DiscStation", "Select mode", "Starting...") else text
         _web_progress = -1
         _web_progress_active = False
+        _web_playing = False
     else:
         return
     _sse_publish(_status_snapshot())
@@ -905,6 +1003,24 @@ def eject_disc(ser, device):
     return ok
 
 
+def close_tray(ser, device):
+    """Close the tray on demand (e.g. the web remote's EJECT/CLOSE toggle,
+    clicked any time after an EJECT - unlike eject_disc's own Linux wait-
+    loop, this isn't limited to a ~60s window). eject_device(close=True) is
+    already cross-platform (eject -t / drutil tray close / eject.ps1
+    -Close), so no per-OS branching is needed here."""
+    global _tray_open
+    safe_send(ser, "STATUS:Closing tray...")
+    try:
+        ok = discstation_host.eject_device(device, close=True)
+    except Exception as e:
+        print(f"Close tray error: {e}")
+        ok = False
+    _tray_open = False
+    safe_send(ser, "STANDBY:Insert disc" if ok else "ERROR:Close failed")
+    return ok
+
+
 HISTORY_FILE = discstation_burn.WORK / "burn_history.jsonl"
 
 
@@ -2519,7 +2635,7 @@ def burn_flow(ser, url):
     job_dir.mkdir()
 
     send(ser, "STATUS:Preflight...")
-    info = discstation_burn.get_video_info(url)
+    info = discstation_burn.get_video_info(url, ser)
     title = info["title"]
     duration = info["duration"]
     duration_line, fit_line, can_fit = discstation_burn.preflight_lines(duration, disc_bytes)
@@ -2738,12 +2854,9 @@ def _copy_to_job(ser, src, dst_dir):
 
 
 def burn_data_flow(ser):
-    global _last_upload_dir, _last_upload_label
+    global _last_upload_label
 
-    if _last_upload_dir and Path(_last_upload_dir).exists():
-        url = _last_upload_dir
-        _last_upload_dir = None
-    elif _stdin_is_tty():
+    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:
@@ -2776,7 +2889,7 @@ def burn_data_flow(ser):
         title = local_path.name if local_path.is_dir() else local_path.stem
     else:
         send(ser, "STATUS:Probing source...")
-        info = discstation_burn.get_video_info(url)
+        info = discstation_burn.get_video_info(url, ser)
         title = info["title"]
 
     if _last_upload_label:
@@ -2936,8 +3049,12 @@ def burn_audio_flow(ser):
     audio_files = []
     audio_exts = {".wav", ".flac", ".mp3", ".aac", ".ogg", ".wma", ".m4a", ".opus"}
     if src_path.is_dir():
-        for f in sorted(src_path.iterdir()):
-            if f.suffix.lower() in audio_exts:
+        # rglob, not iterdir: a browser folder upload preserves the
+        # original relative paths (e.g. "Album Name/track.flac"), so the
+        # audio files usually sit one level below src_path, not at its
+        # top - a plain iterdir() only ever saw the subfolder itself.
+        for f in sorted(src_path.rglob("*")):
+            if f.is_file() and f.suffix.lower() in audio_exts:
                 audio_files.append(f)
     elif src_path.is_file():
         audio_files = [src_path]
@@ -3233,19 +3350,151 @@ def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None):
             pass
 
 
+def _play_audio_cd_windows(ser, device, track_titles):
+    """Play an audio CD via src/win/play-audio-cd.ps1 (Windows Media
+    Player's COM control) - mpv on Windows has no libcdio, so cdda:// is
+    unavailable there. Controlled through a small command file instead of
+    mpv's JSON-IPC socket (a different player, a different protocol);
+    OLED button presses translate to PAUSE/STOP/NEXT/PREV/VOL: writes."""
+    cmd_file = Path(tempfile.gettempdir()) / "discstation_wmp_cmd.txt"
+    cmd_file.unlink(missing_ok=True)
+    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()
+
+    def send_cmd(text):
+        cmd_file.write_text(text + "\n")
+
+    paused = False
+    current_track = -1
+    send(ser, "PLAY_MODE:AUDIO_CD")
+    send(ser, "PLAY:PLAYING")
+    print("Playing audio CD (Windows Media Player). Short press toggles pause; long press stops.")
+
+    last_ping = time.time()
+    try:
+        while proc.poll() is None:
+            now = time.time()
+            if now - last_ping >= 5:
+                last_ping = now
+                safe_send(ser, "PING")
+
+            try:
+                line = lines.get(timeout=0.1)
+            except Empty:
+                line = None
+            if line:
+                if line.startswith("TRACK:"):
+                    try:
+                        track = int(line.split(":", 1)[1])
+                    except ValueError:
+                        track = None
+                    if track is not None and track != current_track:
+                        current_track = track
+                        title = track_titles[track] if 0 <= track < len(track_titles) else ""
+                        status = f"TRACK {track + 1:02d}"
+                        if title:
+                            status += f" // {title}"
+                        send(ser, f"PLAY_STATUS:{status}")
+                elif line == "DONE":
+                    break
+                elif line.startswith("ERROR:"):
+                    raise RuntimeError(line[6:])
+
+            if ser.in_waiting:
+                btn = ser.readline().decode(errors="ignore").strip()
+                discstation_burn.note_serial_activity()
+
+                if btn == "PLAY_BUTTON":
+                    paused = not paused
+                    send_cmd("PAUSE")
+                    send(ser, "PLAY_STATUS:PAUSED" if paused else "PLAY_STATUS:PLAYING")
+
+                elif btn == "PLAY_STOP":
+                    send(ser, "STATUS:Stopping play")
+                    send_cmd("STOP")
+                    break
+
+                elif btn == "FF:BIG" or btn.startswith("FF:"):
+                    send_cmd("NEXT")
+                    send(ser, "PLAY_STATUS:Next track")
+
+                elif btn == "REW:BIG" or btn.startswith("REW:"):
+                    send_cmd("PREV")
+                    send(ser, "PLAY_STATUS:Prev track")
+
+                elif btn.startswith("POT:"):
+                    try:
+                        volume = int(btn.split(":", 1)[1])
+                        send_cmd(f"VOL:{volume}")
+                    except (ValueError, OSError):
+                        pass
+
+            time.sleep(0.02)
+    finally:
+        try:
+            send_cmd("STOP")
+        except OSError:
+            pass
+        time.sleep(0.3)
+        if proc.poll() is None:
+            discstation_burn.stop_process(proc)
+        cmd_file.unlink(missing_ok=True)
+    safe_send(ser, "DONE:Playback stopped")
+    time.sleep(3)
+
+
 def play_flow(ser):
     device = discstation_burn.disc_device()
     kind = disc_kind(device)
     print(f"Disc type: {kind}")
 
-    if not shutil.which("mpv"):
-        raise RuntimeError("mpv not found")
+    mpv = None
+    if not (discstation_host.system_name() == "windows" and kind == "audio_cd"):
+        # The Windows audio_cd path plays via Windows Media Player's own COM
+        # control, not mpv - no reason to require mpv just for that.
+        try:
+            mpv = discstation_burn.tool("mpv")
+        except FileNotFoundError:
+            raise RuntimeError("mpv not found")
+
+    def play_vob_fallback():
+        # 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).
+        with mounted_disc(device) as mount_dir:
+            video_ts = mount_dir / "VIDEO_TS"
+            files = sorted(
+                path for path in video_ts.glob("VTS_01_*.VOB")
+                if re.search(r"_\d+\.VOB$", path.name, re.IGNORECASE)
+                and not path.name.upper().endswith("_0.VOB")
+            )
+            if not files:
+                raise RuntimeError("No playable DVD title found")
+            cmd = [
+                mpv,
+                "--input-ipc-server=" + MPV_SOCKET,
+                "--force-window=yes",
+                "--idle=no",
+                *[str(path) for path in files],
+            ]
+            _run_mpv(ser, cmd, "Playing DVD", kind)
 
     if kind == "dvd_video":
         if discstation_host.system_name() == "darwin":
             try:
                 cmd = [
-                    "mpv",
+                    mpv,
                     "--input-ipc-server=" + MPV_SOCKET,
                     "--force-window=yes",
                     "--idle=no",
@@ -3254,51 +3503,37 @@ def play_flow(ser):
                 ]
                 _run_mpv(ser, cmd, "Playing DVD", kind)
             except RuntimeError:
-                # libdvdnav couldn't open the disc — fall back to playing the
-                # main title's VOBs off the mounted volume (no menus).
-                with mounted_disc(device) as mount_dir:
-                    video_ts = mount_dir / "VIDEO_TS"
-                    files = sorted(
-                        path for path in video_ts.glob("VTS_01_*.VOB")
-                        if re.search(r"_\d+\.VOB$", path.name, re.IGNORECASE)
-                        and not path.name.upper().endswith("_0.VOB")
-                    )
-                    if not files:
-                        raise RuntimeError("No playable DVD title found")
-                    cmd = [
-                        "mpv",
-                        "--input-ipc-server=" + MPV_SOCKET,
-                        "--force-window=yes",
-                        "--idle=no",
-                        *[str(path) for path in files],
-                    ]
-                    _run_mpv(ser, cmd, "Playing DVD", kind)
+                # libdvdnav couldn't open the disc.
+                play_vob_fallback()
         else:
+            # Windows' only reliably-fetchable mpv build (a plain .zip, no
+            # 7z/rar tooling needed) has no libdvdnav - --dvd-device isn't
+            # even a recognized option in it, so don't waste a doomed
+            # attempt; go straight to the VOB fallback.
+            play_vob_fallback()
+
+    elif kind == "audio_cd":
+        _, track_titles, track_starts = audio_track_metadata(device)
+        if discstation_host.system_name() == "windows":
+            # mpv on Windows has no libcdio - cdda:// is unavailable there
+            # ("disabled at compile-time"). Windows Media Player's own COM
+            # control plays it fine via Windows' native CD-audio support.
+            _play_audio_cd_windows(ser, device, track_titles)
+        else:
+            audio_device = discstation_host.audio_output_device()
             cmd = [
-                "mpv",
+                mpv,
                 "--input-ipc-server=" + MPV_SOCKET,
-                "--force-window=yes",
+                "--force-window=no",
                 "--idle=no",
-                device,
+                "--cdrom-device=" + rip_device(device),
+                "--cdda-cdtext=yes",
+                "cdda://",
             ]
-            _run_mpv(ser, cmd, "Playing DVD", kind)
-
-    elif kind == "audio_cd":
-        _, track_titles, track_starts = audio_track_metadata(device)
-        audio_device = discstation_host.audio_output_device()
-        cmd = [
-            "mpv",
-            "--input-ipc-server=" + MPV_SOCKET,
-            "--force-window=no",
-            "--idle=no",
-            "--cdrom-device=" + rip_device(device),
-            "--cdda-cdtext=yes",
-            "cdda://",
-        ]
-        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)
+            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)
 
     elif kind in ("vcd", "svcd", "video_data"):
         with mounted_disc(device) as mount_dir:
@@ -3306,7 +3541,7 @@ def play_flow(ser):
             if not files:
                 raise RuntimeError("No playable video files")
             cmd = [
-                "mpv",
+                mpv,
                 "--input-ipc-server=" + MPV_SOCKET,
                 "--force-window=yes",
                 "--idle=no",
@@ -3395,11 +3630,13 @@ def _handbrake_json_blocks(text):
 def handbrake_scan(device):
     """Return {'main_feature': int|None, 'titles': [{index,duration_s,chapters}]}
     or None. Uses HandBrakeCLI, which does real main-feature detection."""
-    if not shutil.which("HandBrakeCLI"):
+    try:
+        handbrake_cli = discstation_burn.tool("HandBrakeCLI")
+    except FileNotFoundError:
         return None
     try:
         r = subprocess.run(
-            ["HandBrakeCLI", "--json", "--scan", "-i", device, "-t", "0"],
+            [handbrake_cli, "--json", "--scan", "-i", device, "-t", "0"],
             capture_output=True, text=True, timeout=180,
         )
     except (OSError, subprocess.TimeoutExpired) as e:
@@ -3431,7 +3668,7 @@ def handbrake_rip_main_feature(ser, device, out_dir, title_index):
     send(ser, f"INFO:HandBrake title {title_index}")
     send(ser, "PROGRESS:0%")
     proc = subprocess.Popen(
-        ["HandBrakeCLI", "--json", "-i", device, "-o", str(dest),
+        [discstation_burn.tool("HandBrakeCLI"), "--json", "-i", device, "-o", str(dest),
          "-t", str(title_index), "-e", "x264", "-q", "20",
          "--all-audio", "--all-subtitles"],
         stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
@@ -3479,6 +3716,50 @@ def rip_flow(ser, artist_hint=None, album_hint=None):
     out_dir = RIP_ROOT / time.strftime("rip_%Y%m%d_%H%M%S")
     out_dir.mkdir(parents=True, exist_ok=True)
 
+    if discstation_host.system_name() == "windows":
+        # Neither dvdbackup nor HandBrakeCLI's libdvdread reliably reads this
+        # drive on Windows (the latter hangs rather than erroring) - skip
+        # both and just mirror the drive with robocopy, a plain recursive
+        # file copy. Same real byte-count progress technique as the
+        # dvdbackup path below (accurate, not an estimate - directory size
+        # vs. known disc size).
+        send(ser, "STATUS:Ripping disc...")
+        send(ser, "INFO:Full VIDEO_TS copy")
+        send(ser, "PROGRESS:0%")
+        source = str(device).rstrip("\\/").rstrip(":") + ":\\"
+        print(f"Ripping {source} to {out_dir}")
+        proc = subprocess.Popen(
+            ["robocopy", source, str(out_dir), "/E", "/R:1", "/W:1"],
+            stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
+        )
+        disc_bytes = device_size_bytes(device)
+        last_pct = -1
+        try:
+            for event in iter_process_events(proc, ser=ser):
+                if event is None and disc_bytes > 0:
+                    pct = min(int(directory_size_bytes(out_dir) / disc_bytes * 100), 99)
+                    if pct > last_pct:
+                        last_pct = pct
+                        send(ser, f"PROGRESS:{pct}%")
+        except CancelError:
+            safe_send(ser, "CANCELLED:Rip cancelled")
+            print("Rip cancelled by user")
+            return
+        except (KeyboardInterrupt, SystemExit):
+            discstation_burn.stop_process(proc)
+            safe_send(ser, "CANCELLED:Rip stopped")
+            raise
+        rc = proc.wait()
+        if rc >= 8:  # robocopy: 0-7 are success variants, only 8+ is a real failure
+            raise RuntimeError(f"robocopy failed (exit {rc})")
+        safe_send(ser, "PROGRESS:100%")
+        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
+
     scan = handbrake_scan(device)
     if scan:
         main = scan["main_feature"]
@@ -3940,7 +4221,17 @@ def station_loop(ser, url, artist_hint=None, album_hint=None):
         if now - last_ping >= 5:
             last_ping = now
             safe_send(ser, "PING")
-            check_serial_alive(ser)
+            if isinstance(ser, VirtualSerial):
+                # Safe point (no flow active) to check whether a real ESP32
+                # has appeared - hand off to it instead of the web remote.
+                try:
+                    port = discstation_host.serial_port()
+                except Exception:
+                    port = None
+                if port:
+                    raise _HardwareAttached(port)
+            else:
+                check_serial_alive(ser)
 
             # Slow full classify as a backstop (type changes, stuck "reading...").
             if (not _tray_open and _disc_poll_future is None
@@ -4002,6 +4293,24 @@ def station_loop(ser, url, artist_hint=None, album_hint=None):
             _detect_cache.pop(device, None)
             continue
 
+        if line == "CONFIRM" and _tray_open:
+            # Reached only outside eject_disc's own ~60s WAITING window (that
+            # loop consumes its own CONFIRM internally) - the web remote's
+            # EJECT/CLOSE toggle sends this any time later to close the tray.
+            try:
+                device = discstation_burn.disc_device()
+            except FileNotFoundError:
+                if discstation_host.system_name() == "darwin":
+                    device = None
+                else:
+                    raise
+            close_tray(ser, device)
+            last_disc_line = None
+            last_status = None
+            last_status_check = 0.0
+            _detect_cache.pop(device, None)
+            continue
+
         if not line.startswith("SELECT:"):
             if line.startswith("WiFi") or line.startswith("IP:") or "ip:" in line.lower():
                 print(f"ESP32: {line}")
@@ -4075,7 +4384,10 @@ def check_pidfile():
                 if alive:
                     print(f"Already running (PID {old_pid}), exiting")
                     sys.exit(0)
-            except (OSError, IOError):
+            except (OSError, IOError, SystemError):
+                # os.kill(pid, 0) on Windows raises SystemError (not OSError)
+                # for some stale/reused PIDs ("WinError 87: The parameter is
+                # incorrect") instead of just saying the process is gone.
                 pass
     except (ValueError, OSError):
         pass
@@ -4098,7 +4410,7 @@ def parse_args():
 
 
 def main():
-    global _active_ser, _line_buf
+    global _active_ser, _line_buf, _appliance_mode
     signal.signal(signal.SIGTERM, signal.SIG_IGN)
     check_pidfile()
 
@@ -4122,18 +4434,32 @@ def main():
             try:
                 _line_buf = b""
                 port = discstation_host.serial_port()
-                if not port:
-                    raise serial.SerialException("No ESP32 serial port found")
-                print(f"Using ESP32 serial port: {port}")
-                ser = serial.Serial(port, discstation_burn.BAUD, timeout=1, write_timeout=1)
-                if discstation_host.system_name() == "linux":
-                    ser.setDTR(False)
-                    time.sleep(0.1)
-                    ser.setDTR(True)
-                time.sleep(2)
-                discstation_burn.reset_serial_state()
+                if port:
+                    print(f"Using ESP32 serial port: {port}")
+                    ser = serial.Serial(port, discstation_burn.BAUD, timeout=1, write_timeout=1)
+                    if discstation_host.system_name() == "linux":
+                        ser.setDTR(False)
+                        time.sleep(0.1)
+                        ser.setDTR(True)
+                    time.sleep(2)
+                    discstation_burn.reset_serial_state()
+                    _appliance_mode = "hardware"
+                else:
+                    # No ESP32 found - run fully useful off the on-screen web
+                    # remote instead of retrying forever (station_loop already
+                    # publishes status via status_sink regardless of ser).
+                    print("No ESP32 found - running in software-only mode (web remote).")
+                    ser = VirtualSerial()
+                    _appliance_mode = "software"
                 _active_ser = ser
+                # Nothing else publishes an SSE update purely for an appliance-
+                # mode flip (STATUS/PROGRESS/etc. events do, this doesn't) - push
+                # 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)
+            except _HardwareAttached:
+                print("ESP32 detected - handing off from the web remote to hardware.")
             except (serial.SerialException, OSError, termios.error) as e:
                 print(f"Disconnected ({e}), reconnecting in 3s...")
                 time.sleep(3)