discstation 0.1.17 → 0.1.20

package/README.md

@@ -64,7 +64,7 @@ Windows.
 |----|-----------|-----------------|
 | Linux | `install.sh` — apt deps, venv, systemd `--user` service, self-signed cert | full burn / rip / play |
 | macOS | `install-macos.sh` — Homebrew deps, venv, launchd agent, cert | burn / rip / play (audio-CD *burning* is best-effort; set `DISC_DEVICE` if detection fails) |
-| Windows | `install-windows.ps1` — files + venv | web / serial control only, no burn backend |
+| Windows | `install-windows.ps1` — Python + venv, self-signed cert, firewall rules, auto-start Scheduled Task | burn (ISO / data / audio CD) via IMAPI2 on Windows 10/11 and 7; DVD rip (HandBrake main-feature mode) and play (mpv) use the shared cross-platform path; full VIDEO_TS mirror rip and audio-CD rip aren't implemented on Windows yet |
 
 ### Or run the platform script directly
 
@@ -80,7 +80,7 @@ arduino-cli lib install QRCode
 # macOS host
 ./install-macos.sh
 
-# Windows host (web/control workflow)
+# Windows host
 PowerShell -ExecutionPolicy Bypass -File .\install-windows.ps1
 ```
 
@@ -88,8 +88,10 @@ PowerShell -ExecutionPolicy Bypass -File .\install-windows.ps1
 
 Linux and macOS both run the complete optical workflow (burn, rip, play) —
 macOS via `xorriso` / `hdiutil` / `cd-paranoia` / `dvdbackup` / HandBrake, with
-audio-CD *burning* the one best-effort area. Windows runs the shared Python/web
-workflow only; it has no burn backend yet. See `docs/PLATFORM_SUPPORT.md`.
+audio-CD *burning* the one best-effort area. Windows burns (ISO / data / audio
+CD) via IMAPI2 and plays via mpv; DVD ripping works in HandBrake main-feature
+mode but not full VIDEO_TS mirror or audio-CD ripping yet. See
+`docs/PLATFORM_SUPPORT.md`.
 
 ## Web Interface
 
@@ -114,7 +116,7 @@ Built-in web server on port 8080 (HTTPS with self-signed cert):
 | `DISC_CLEANUP_DAYS` | 2 | Auto-cleanup old job directories |
 | `DISC_OUTPUT_LIMIT_BYTES` | 4300000000 | Conservative DVD5 payload limit |
 | `DISC_DL_OUTPUT_LIMIT_BYTES` | 8000000000 | Conservative DVD9 payload limit |
-| `DISC_DEVICE` | auto | Optical drive node override (required on Windows) |
+| `DISC_DEVICE` | auto | Optical drive node override |
 | `DISC_PORT` | auto | ESP32 serial port override |
 | `DISCSTATION_HTTP_PORT` | 8081 | Plain-HTTP port for the mobile app (`0` disables) |
 | `DISCSTATION_DVD_RIP_MODE` | mirror | `mkv` = HandBrake main-feature transcode instead of a full VIDEO_TS mirror |

package/docs/PLATFORM_SUPPORT.md

@@ -29,10 +29,28 @@ the drive on recent macOS; DiscStation reports this clearly instead of hanging.
 
 ## Windows
 
-The Python host and web/control workflow can run from PowerShell. Optical
-burning needs a Windows IMAPI backend or a separately installed compatible
-burning tool. The Windows installer deliberately reports this limitation
-instead of silently attempting Linux commands.
+Runs the same Python host and web UI as Linux/macOS, triggered the same way
+via the ESP32 OLED remote. `install-windows.ps1` sets up Python + venv, a
+self-signed cert, firewall rules for 8080/8081, and a per-user auto-start
+Scheduled Task (headless `pythonw.exe`, no admin needed).
+
+- **Detect / eject** — WMI (`Win32_CDROMDrive`, `Win32_LogicalDisk`) + IMAPI2
+  for media type, blank/rewritable state, and capacity
+  (`src/win/disc-info.ps1`, `src/win/eject.ps1`).
+- **Burn** — data, ISO, and audio CD all go through IMAPI2
+  (`src/win/burn-{image,data,audio}.ps1`), with live progress streamed to the
+  OLED; `isoburn.exe /q` is the zero-dependency fallback for a raw ISO.
+  Works on Windows 7 SP1 and 10/11.
+- **Rip** — DVD main-feature mode via HandBrakeCLI (winget on 10/11) works;
+  a full unencrypted VIDEO_TS mirror and audio-CD ripping aren't implemented
+  yet (no Windows path for `dvdbackup`/`cd-paranoia`).
+- **Play** — `mpv`, via the same code path as Linux/macOS (device letter for
+  DVD-Video, `cdda://` for audio CD, mounted drive for data/VCD).
+
+Windows 7 (no `winget`) gets the host, detection, eject, and all three burn
+modes; rip/play need tools that don't install cleanly on 7, so those OLED
+actions report "not supported" there. Set `DISC_DEVICE` to override drive
+auto-detection.
 
 ## Shared Components
 
@@ -43,4 +61,5 @@ instead of silently attempting Linux commands.
 - QR-code web URL display
 
 The optical-drive backend is the platform boundary. Linux and macOS are
-complete (bar macOS audio-CD burning); Windows still needs its writer backend.
+complete (bar macOS audio-CD burning); Windows burns and plays, with DVD-mirror
+and audio-CD ripping still to come.

package/install-windows.ps1

@@ -1,29 +1,150 @@
+# DiscStation host installer for Windows 10/11 (and best-effort on 7 SP1).
+#   powershell -ExecutionPolicy Bypass -File install-windows.ps1
+# Sets up: Python + venv, optical CLI tools (winget), self-signed cert,
+# a per-user auto-start Scheduled Task, and inbound firewall rules for 8080/8081.
 $ErrorActionPreference = "Stop"
+$ProgressPreference = "SilentlyContinue"  # Invoke-WebRequest's progress bar breaks over SSH/non-interactive hosts
 
-$Root = Split-Path -Parent $MyInvocation.MyCommand.Path
-$App = if ($env:DISCSTATION_APP_DIR) { $env:DISCSTATION_APP_DIR } else { Join-Path $env:LOCALAPPDATA "DiscStation\app" }
-$Venv = if ($env:DISCSTATION_VENV_DIR) { $env:DISCSTATION_VENV_DIR } else { Join-Path $env:LOCALAPPDATA "DiscStation\venv" }
+$Root   = Split-Path -Parent $MyInvocation.MyCommand.Path
+$Base   = if ($env:DISCSTATION_CONFIG_DIR) { $env:DISCSTATION_CONFIG_DIR } else { Join-Path $env:APPDATA "DiscStation" }
+$App    = if ($env:DISCSTATION_APP_DIR)    { $env:DISCSTATION_APP_DIR }    else { Join-Path $Base "app" }
+$Venv   = if ($env:DISCSTATION_VENV_DIR)   { $env:DISCSTATION_VENV_DIR }   else { Join-Path $Base "venv" }
+$IsWin7 = [Environment]::OSVersion.Version.Major -eq 6
+$winget = (Get-Command winget -ErrorAction SilentlyContinue)
 
-if (-not (Get-Command py -ErrorAction SilentlyContinue)) {
-    throw "Install Python 3 from https://www.python.org/downloads/windows/ first."
+function Have($name) { [bool](Get-Command $name -ErrorAction SilentlyContinue) }
+function Winget-Install($id) {
+    if (-not $winget) { return $false }
+    try { winget install -e --id $id --accept-source-agreements --accept-package-agreements --silent | Out-Null; return $true }
+    catch { Write-Host "  winget $id failed (skipping)"; return $false }
 }
 
-New-Item -ItemType Directory -Force -Path $App, $Venv | Out-Null
+# --- 1. Python -------------------------------------------------------------------
+if (-not (Have "python") -and -not (Have "py")) {
+    Write-Host "Installing Python..."
+    if ($winget -and -not $IsWin7) {
+        Winget-Install "Python.Python.3.12" | Out-Null
+        $env:Path = [System.Environment]::GetEnvironmentVariable("Path", "User") + ";" + $env:Path
+    } else {
+        $pyver = if ($IsWin7) { "3.8.10" } else { "3.12.6" }
+        $url = "https://www.python.org/ftp/python/$pyver/python-$pyver-amd64.exe"
+        $exe = Join-Path $env:TEMP "python-$pyver-amd64.exe"
+        Invoke-WebRequest $url -OutFile $exe -UseBasicParsing
+        Start-Process $exe -ArgumentList "/quiet","InstallAllUsers=0","PrependPath=1","Include_test=0" -Wait
+        $env:Path = (Join-Path $env:LOCALAPPDATA "Programs\Python\Python$($pyver.Substring(0,4) -replace '\.','')") + ";" + $env:Path + ";" +
+                    (Join-Path $env:LOCALAPPDATA "Programs\Python\Python$($pyver.Substring(0,4) -replace '\.','')\Scripts")
+    }
+}
+if (Have "python") { $PyExe = "python"; $PyArgs = @() }
+elseif (Have "py") { $PyExe = "py"; $PyArgs = @("-3") }
+else { throw "Python install failed. Install Python 3 manually and re-run." }
+
+# --- 2. Optical CLI tools (winget when available; Win10/11 only; best-effort,
+#        strictly time-bounded so a slow/blocked mirror can never hang the install) --
+if ($winget -and -not $IsWin7) {
+    Write-Host "Installing optical tools via winget (best effort)..."
+    foreach ($id in "libburnia.xorriso","mpv.mpv","HandBrake.HandBrake.CLI","Gyan.FFmpeg","yt-dlp.yt-dlp") {
+        Winget-Install $id | Out-Null
+    }
+} elseif (-not $IsWin7) {
+    Write-Host "winget unavailable - fetching optical tools directly (best effort, 25s timeout each)..."
+    $tools = Join-Path $Base "tools"
+    New-Item -ItemType Directory -Force -Path $tools | Out-Null
+    function Get-Zip($url, $dest) {
+        try {
+            $zip = Join-Path $env:TEMP ([IO.Path]::GetFileName($url))
+            Invoke-WebRequest $url -OutFile $zip -UseBasicParsing -TimeoutSec 25
+            Expand-Archive -Path $zip -DestinationPath $dest -Force
+            Remove-Item $zip -ErrorAction SilentlyContinue
+            return $true
+        } catch { Write-Host "  fetch failed: $url"; return $false }
+    }
+    if (-not (Have "yt-dlp")) {
+        try { Invoke-WebRequest "https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp.exe" -OutFile (Join-Path $tools "yt-dlp.exe") -UseBasicParsing -TimeoutSec 25 }
+        catch { Write-Host "  yt-dlp fetch skipped" }
+    }
+    if (-not (Have "ffmpeg")) { Get-Zip "https://www.gyan.dev/ffmpeg/builds/ffmpeg-release-essentials.zip" $tools | Out-Null }
+    if (-not (Have "mpv")) { Get-Zip "https://sourceforge.net/projects/mpv-player-windows/files/latest/download" $tools | Out-Null }
+    if (Test-Path $tools) {
+        $env:Path = $env:Path + ";" + $tools + ";" +
+            ((Get-ChildItem $tools -Recurse -Filter "ffmpeg.exe" -ErrorAction SilentlyContinue | Select-Object -First 1).DirectoryName)
+    }
+    Write-Host "xorriso and HandBrakeCLI have no simple direct-download URL - install manually if you need"
+    Write-Host "video-DVD authoring / DVD ripping (see the plan's Windows setup notes)."
+} else {
+    Write-Host "winget unavailable (Windows 7). ISO + data + audio burn work via IMAPI2."
+    Write-Host "For rip/play/video-DVD install manually: xorriso, HandBrakeCLI 1.5.1, ffmpeg, mpv, yt-dlp."
+}
+
+# --- 3. App files + venv ------------------------------------------------------
+New-Item -ItemType Directory -Force -Path $Base, $App | Out-Null
 Copy-Item -Recurse -Force (Join-Path $Root "src\*") $App
-py -3 -m venv $Venv
-& (Join-Path $Venv "Scripts\python.exe") -m pip install --upgrade pip
+& $PyExe @PyArgs -m venv $Venv
 $Py = Join-Path $Venv "Scripts\python.exe"
+& $Py -m pip install --upgrade pip
 $Req = Join-Path $Root "requirements.txt"
-if (Test-Path $Req) {
-    & $Py -m pip install -r $Req
-} else {
-    & $Py -m pip install pyserial mutagen requests yt-dlp
+if (Test-Path $Req) { & $Py -m pip install -r $Req } else { & $Py -m pip install pyserial mutagen requests yt-dlp }
+$Opt = Join-Path $Root "requirements-optional.txt"
+try { if (Test-Path $Opt) { & $Py -m pip install -r $Opt } else { & $Py -m pip install musicbrainzngs tmdbsimple } }
+catch { Write-Host "Optional metadata deps skipped (host still works)." }
+
+# --- 4. Self-signed cert (HTTPS on :8080; :8081 works without it) --------------
+$crt = Join-Path $Base "server.crt"; $key = Join-Path $Base "server.key"
+if (-not (Test-Path $crt) -or -not (Test-Path $key)) {
+    try {
+        $c = New-SelfSignedCertificate -DnsName "discstation.local" -CertStoreLocation "Cert:\CurrentUser\My" -NotAfter (Get-Date).AddYears(10)
+        $pwd = ConvertTo-SecureString -String "discstation" -Force -AsPlainText
+        $pfx = Join-Path $env:TEMP "ds.pfx"
+        Export-PfxCertificate -Cert $c -FilePath $pfx -Password $pwd | Out-Null
+        & $Py -c "import ssl" 2>$null
+        # Convert PFX -> PEM via Python cryptography if present, else leave HTTPS off.
+        & $Py -m pip install cryptography 2>$null
+        & $Py -c "import sys;from cryptography.hazmat.primitives.serialization import pkcs12,Encoding,PrivateFormat,NoEncryption;d=open(sys.argv[1],'rb').read();k,c,_=pkcs12.load_key_and_certificates(d,b'discstation');open(sys.argv[2],'wb').write(c.public_bytes(Encoding.PEM));open(sys.argv[3],'wb').write(k.private_bytes(Encoding.PEM,PrivateFormat.TraditionalOpenSSL,NoEncryption()))" $pfx $crt $key
+        Remove-Item $pfx -ErrorAction SilentlyContinue
+    } catch { Write-Host "Cert generation skipped; the host will serve plain HTTP on 8081." }
 }
-# Optional metadata deps — best effort, never fatal.
-try { & $Py -m pip install musicbrainzngs tmdbsimple } catch {
-    Write-Host "Optional metadata deps skipped (host still works)."
+
+# --- 5. Firewall -------------------------------------------------------------
+foreach ($port in 8080, 8081) {
+    $name = "DiscStation $port"
+    try {
+        if (Get-Command New-NetFirewallRule -ErrorAction SilentlyContinue) {
+            if (-not (Get-NetFirewallRule -DisplayName $name -ErrorAction SilentlyContinue)) {
+                New-NetFirewallRule -DisplayName $name -Direction Inbound -Action Allow -Protocol TCP -LocalPort $port | Out-Null
+            }
+        } else {
+            netsh advfirewall firewall add rule name="$name" dir=in action=allow protocol=TCP localport=$port | Out-Null
+        }
+    } catch {}
 }
 
-Write-Host "DiscStation host files installed at $App"
-Write-Host "The web/control workflow is available; optical burning requires a Windows IMAPI backend or compatible burning tools."
-Write-Host "Run: $Venv\Scripts\python.exe $App\discstation.py"
+# --- 6. Auto-start Scheduled Task -----------------------------------------------
+$pyw = Join-Path $Venv "Scripts\pythonw.exe"
+$target = Join-Path $App "discstation.py"
+try {
+    if (Get-Command Register-ScheduledTask -ErrorAction SilentlyContinue) {
+        $action    = New-ScheduledTaskAction -Execute $pyw -Argument "`"$target`"" -WorkingDirectory $App
+        $trigger   = New-ScheduledTaskTrigger -AtLogOn -User $env:USERNAME
+        $set       = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -RestartCount 3 -RestartInterval (New-TimeSpan -Minutes 1)
+        # S4U: runs headlessly for this user without needing an active interactive
+        # desktop session (Interactive logon type only fires while one exists, so
+        # e.g. Start-ScheduledTask over SSH/no console session would silently no-op).
+        # RunLevel Limited (standard, non-elevated): nothing here needs admin -
+        # IMAPI2 burning, WMI reads, and binding ports >1024 all work as a normal
+        # user, and elevation is what put "Administrator" on the flashing console
+        # windows this used to spawn.
+        $principal = New-ScheduledTaskPrincipal -UserId $env:USERNAME -LogonType S4U -RunLevel Limited
+        Register-ScheduledTask -TaskName "DiscStation" -Action $action -Trigger $trigger -Settings $set -Principal $principal -Force | Out-Null
+        Start-ScheduledTask -TaskName "DiscStation"
+    } else {
+        schtasks /create /tn "DiscStation" /sc onlogon /f /tr "`"$pyw`" `"$target`"" | Out-Null
+        schtasks /run /tn "DiscStation" | Out-Null
+    }
+} catch { Write-Host "Auto-start task not created: $_" }
+
+$ip = (Get-NetIPAddress -AddressFamily IPv4 -ErrorAction SilentlyContinue | Where-Object { $_.IPAddress -notmatch '^127\.|^169\.254\.' } | Select-Object -First 1).IPAddress
+Write-Host ""
+Write-Host "DiscStation installed at $App"
+Write-Host "  Web UI:  http://localhost:8081/   (also http://$ip`:8081 on the LAN)"
+Write-Host "  Run 'discstation' any time to open it. Detection/eject/ISO+data+audio burn use IMAPI2 (no extra tools)."
+try { node (Join-Path $Root "scripts\open.mjs") } catch {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discstation",
-  "version": "0.1.17",
+  "version": "0.1.20",
   "description": "DiscStation optical-media appliance host — one cross-OS installer",
   "bin": {
     "discstation-setup": "scripts/setup.mjs",
@@ -21,6 +21,7 @@
     "scripts/",
     "src/*.py",
     "src/static/",
+    "src/win/",
     "arduino/",
     "systemd/",
     "docs/",

package/scripts/setup.mjs

@@ -19,7 +19,7 @@ if (args.includes('-h') || args.includes('--help')) {
 Runs the installer for the current OS:
   linux    install.sh          full: apt deps, venv, systemd --user service, self-signed cert
   darwin   install-macos.sh    full: Homebrew deps, venv, launchd agent, cert (audio-CD burn is best-effort)
-  windows  install-windows.ps1 files + venv only; web/serial control, no burn backend
+  windows  install-windows.ps1 venv + cert + firewall + auto-start task; burn via IMAPI2 (10/11 and 7)
 
 Prereqs: Node 16+, Python 3 (python3 / py on PATH), and either bash (linux/macOS)
 or PowerShell (Windows). Homebrew is auto-installed on macOS if missing; the

package/src/discstation.py

@@ -4,7 +4,10 @@ import atexit
 import collections
 import concurrent.futures
 import errno
-import fcntl
+try:
+    import fcntl  # POSIX-only; used only in drive_status()'s Linux branch
+except ImportError:
+    fcntl = None
 import json
 import mimetypes
 import os
@@ -16,7 +19,10 @@ except ImportError:
 import re
 import shutil
 import socket
-import ssl
+try:
+    import ssl  # optional: HTTPS on :8080. The plain-HTTP :8081 listener works without it.
+except ImportError:
+    ssl = None
 import subprocess
 import sys
 import tempfile
@@ -53,6 +59,8 @@ _last_upload_label = None
 _web_status = "READY"
 _web_progress = -1
 _web_progress_active = False
+_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
 STATIC_DIR = Path(__file__).resolve().parent / "static"
 
@@ -146,6 +154,10 @@ class _WebHandler(http.server.BaseHTTPRequestHandler):
         self._respond(200, f'{len(files)} file(s) uploaded ({size_str}). Select BURN DATA on remote.')
 
     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")
+            return
         info = {"disc_present": False, "capacity_bytes": 0, "capacity_gb": 0, "type": "none"}
         try:
             device = discstation_burn.disc_device()
@@ -163,6 +175,7 @@ class _WebHandler(http.server.BaseHTTPRequestHandler):
             info["label"] = di.label
         except Exception as e:
             print(f"Disc info error: {e}")
+        _last_disc_info.update(info)
         self._respond(200, json.dumps(info), "application/json")
 
     def _serve_sse(self):
@@ -212,7 +225,7 @@ class _WebHandler(http.server.BaseHTTPRequestHandler):
     def _serve_sw(self):
         sw = '''self.addEventListener('install', e => {
   self.skipWaiting();
-  caches.open('discstation-v7').then(c => c.addAll(['/','/static/style.css?v=7','/static/app.js?v=7']));
+  caches.open('discstation-v8').then(c => c.addAll(['/','/static/style.css?v=8','/static/app.js?v=8']));
 });
 self.addEventListener('activate', e => e.waitUntil(clients.claim()));
 self.addEventListener('fetch', e => {
@@ -221,7 +234,7 @@ self.addEventListener('fetch', e => {
   if (path === '/' || path.startsWith('/static/')) {
     e.respondWith(fetch(e.request).then(r => {
       const copy = r.clone();
-      caches.open('discstation-v7').then(c => c.put(e.request, copy));
+      caches.open('discstation-v8').then(c => c.put(e.request, copy));
       return r;
     }).catch(() => caches.match(e.request)));
   } else {
@@ -342,13 +355,17 @@ def start_web_server(port=8080):
     cert_dir = discstation_host.config_dir()
     cert = cert_dir / 'server.crt'
     key = cert_dir / 'server.key'
-    if cert.exists() and key.exists():
-        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
-        ctx.load_cert_chain(str(cert), str(key))
-        server.socket = ctx.wrap_socket(server.socket, server_side=True)
-        print(f"Web interface on https://0.0.0.0:{port}")
+    if ssl is not None and cert.exists() and key.exists():
+        try:
+            ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+            ctx.load_cert_chain(str(cert), str(key))
+            server.socket = ctx.wrap_socket(server.socket, server_side=True)
+            print(f"Web interface on https://0.0.0.0:{port}")
+        except (ssl.SSLError, OSError) as e:
+            print(f"TLS disabled ({e}); serving plain HTTP on {port}")
     else:
-        print(f"Web interface on http://0.0.0.0:{port}")
+        print(f"Web interface on http://0.0.0.0:{port}"
+              + ("" if ssl is not None else " (ssl module unavailable)"))
 
     _web_server = server
     t = threading.Thread(target=server.serve_forever, daemon=True)
@@ -415,7 +432,8 @@ def wait_for_web_url(ser):
             check_serial_alive(ser)
 
 
-MPV_SOCKET = str(Path(tempfile.gettempdir()) / "discstation_mpv.sock")
+MPV_SOCKET = (r"\\.\pipe\discstation-mpv" if os.name == "nt"
+              else str(Path(tempfile.gettempdir()) / "discstation_mpv.sock"))
 RIP_ROOT = discstation_burn.USER_HOME / "dvd_rips"
 USER_AGENT = "DVDStation/0.1 (local appliance; phuju)"
 DISC_POLL_SECONDS = 6
@@ -642,12 +660,26 @@ def chown_to_sudo_user(path):
                 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."""
+    if os.name == "nt":
+        with open(MPV_SOCKET, "r+b", buffering=0) as pipe:
+            pipe.write(payload)
+            if timeout is None:
+                return b""
+            return pipe.read(4096) or b""
+    with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
+        if timeout is not None:
+            sock.settimeout(timeout)
+        sock.connect(MPV_SOCKET)
+        sock.sendall(payload)
+        return sock.recv(4096) if timeout is not None else b""
+
+
 def mpv_command(command):
     try:
-        payload = json.dumps({"command": command}).encode() + b"\n"
-        with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
-            sock.connect(MPV_SOCKET)
-            sock.sendall(payload)
+        _mpv_ipc(json.dumps({"command": command}).encode() + b"\n")
     except OSError:
         return False
     return True
@@ -656,11 +688,7 @@ def mpv_command(command):
 def mpv_query(command):
     try:
         payload = json.dumps({"command": command, "request_id": 1}).encode() + b"\n"
-        with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
-            sock.settimeout(0.5)
-            sock.connect(MPV_SOCKET)
-            sock.sendall(payload)
-            response = json.loads(sock.recv(4096).decode(errors="ignore"))
+        response = json.loads(_mpv_ipc(payload, timeout=0.5).decode(errors="ignore"))
         return response.get("data")
     except (OSError, ValueError, json.JSONDecodeError):
         return None
@@ -671,14 +699,11 @@ def wait_for_socket(path, proc, timeout=8):
     while time.time() < deadline:
         if proc.poll() is not None:
             return False
-        if Path(path).exists():
-            try:
-                with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
-                    sock.settimeout(0.25)
-                    sock.connect(path)
-                return True
-            except OSError:
-                pass
+        try:
+            _mpv_ipc(b'{"command":["get_property","idle-active"]}\n', timeout=0.25)
+            return True
+        except OSError:
+            pass
         time.sleep(0.1)
     return False
 
@@ -991,11 +1016,28 @@ _tray_open = False
 _tray_open_since = 0.0  # time.monotonic() of the last OLED-initiated eject
 
 
+def _device_present(device):
+    """Is `device` still a live drive node? On Linux/macOS that's a real
+    filesystem path that can disappear (e.g. after an eject) - Path.exists()
+    answers that correctly. On Windows `device` is a bare drive letter ("D:");
+    Path("D:").exists() raises OSError (WinError 1) instead of returning False,
+    and the drive letter is stable regardless of media state anyway (the real
+    presence signal is ID_CDROM_MEDIA, checked downstream via media_properties())."""
+    if not device:
+        return False
+    if discstation_host.system_name() == "windows":
+        return True
+    try:
+        return Path(device).exists()
+    except OSError:
+        return False
+
+
 def _tray_closed_with_disc(device):
     if not device:
         return False
     global _tray_open
-    if not Path(device).exists():
+    if not _device_present(device):
         return False
     properties = udev_cdrom_properties(device)
     if properties.get("ID_CDROM_MEDIA") == "1":
@@ -1014,7 +1056,7 @@ def disc_present(device):
         return True
     if _tray_open:
         return False
-    if not Path(device).exists():
+    if not _device_present(device):
         return False
     if discstation_host.system_name() != "linux":
         properties = udev_cdrom_properties(device)
@@ -1048,7 +1090,7 @@ def disc_present(device):
 def is_blank_disc(device):
     if not device:
         return False
-    if not Path(device).exists():
+    if not _device_present(device):
         return False
 
     properties = udev_cdrom_properties(device, refresh=True)
@@ -1100,7 +1142,7 @@ def is_rewritable_disc(device):
     if not device:
         return False
     """Return whether the inserted medium can be overwritten."""
-    if not Path(device).exists():
+    if not _device_present(device):
         return False
 
     properties = udev_cdrom_properties(device)
@@ -1220,7 +1262,7 @@ def _media_quick_state(device, props):
         return "unsure"
     # st == "unknown": fall through to the legacy probes below
     try:
-        if not Path(device).exists():
+        if not _device_present(device):
             return "empty"
     except OSError:
         return "empty"
@@ -1310,6 +1352,11 @@ def _classify_disc(device, props, failed, deadline):
     (blkid -> lsdvd -> wodim -toc -> fs fallback -> blank) but records which
     probes timed out / were missing so the caller can retry."""
     if discstation_host.system_name() != "linux":
+        if not props.get("ID_CDROM_MEDIA"):
+            # media_properties() returned nothing -> no disc loaded (this is the
+            # only "no media" signal on a platform like Windows where the drive
+            # letter/device path exists whether or not media is present).
+            return _disc_info(False, "none")
         if props.get("ID_CDROM_MEDIA_TYPE") == "audio":
             return _disc_info(True, "audio_cd", web_type="AUDIO_CD")
         if props.get("ID_FS_TYPE") in ("udf", "iso9660"):
@@ -1620,6 +1667,11 @@ class mounted_disc:
         self.owned_mount = False
 
     def __enter__(self):
+        if discstation_host.system_name() == "windows":
+            # the optical disc is already mounted by the OS as its drive letter
+            letter = str(self.device).rstrip("\\/").rstrip(":") + ":\\"
+            self.mount_path = Path(letter)
+            return self.mount_path
         if discstation_host.system_name() == "darwin":
             properties = discstation_host.media_properties(self.device)
             existing_mount = properties.get("ID_MOUNT_POINT")
@@ -1681,6 +1733,24 @@ def disc_video_files(mount_dir):
 
 
 def audio_cd_toc(device):
+    if discstation_host.system_name() == "windows":
+        rc, out, err = discstation_host._run_ps("audio-toc.ps1", device, timeout=25)
+        info = {}
+        for line in out.splitlines():
+            if line.strip().startswith("{"):
+                try:
+                    info = json.loads(line)
+                except ValueError:
+                    pass
+        tracks = info.get("tracks") or []
+        if not tracks:
+            raise RuntimeError(f"Could not read CD TOC: {(err or out)[:120]}")
+        n = int(info["track_count"])
+        return {
+            "first_track": 1, "track_count": n, "leadout": int(info["leadout"]),
+            "tracks": tracks,
+            "toc": "+".join(map(str, [1, n, int(info["leadout"]), *tracks])),
+        }
     if discstation_host.system_name() == "darwin":
         paranoia = None
         for name in ("cd-paranoia", "cdparanoia"):
@@ -1760,7 +1830,7 @@ def audio_cd_toc(device):
 
 
 def audio_cd_chapters(device):
-    if discstation_host.system_name() == "darwin":
+    if discstation_host.system_name() in ("darwin", "windows"):
         toc = audio_cd_toc(device)
         tracks = toc["tracks"]
         first = tracks[0]
@@ -2406,9 +2476,18 @@ 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 burn_flow(ser, url):
     if not url:
-        if sys.stdin.isatty():
+        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:
@@ -2664,7 +2743,7 @@ def burn_data_flow(ser):
     if _last_upload_dir and Path(_last_upload_dir).exists():
         url = _last_upload_dir
         _last_upload_dir = None
-    elif sys.stdin.isatty():
+    elif _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:
@@ -2829,7 +2908,7 @@ def burn_data_flow(ser):
 
 
 def burn_audio_flow(ser):
-    if sys.stdin.isatty():
+    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:
@@ -3010,7 +3089,7 @@ def _iter_proc_lines(proc, ser):
 def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None):
     try:
         os.unlink(MPV_SOCKET)
-    except FileNotFoundError:
+    except OSError:
         pass
 
     env = os.environ.copy()
@@ -3150,7 +3229,7 @@ def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None):
             discstation_burn.stop_process(proc)
         try:
             os.unlink(MPV_SOCKET)
-        except FileNotFoundError:
+        except OSError:
             pass
 
 
@@ -3731,7 +3810,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
+    global _last_burn_result, _last_burn_result_time, _tray_open, _tray_open_since, _operation_active
     discstation_burn.cleanup_old_jobs()
     try:
         device = discstation_burn.disc_device()
@@ -3934,6 +4013,7 @@ def station_loop(ser, url, artist_hint=None, album_hint=None):
         # 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.
         _tray_open = False
+        _operation_active = True  # stop /disc-info probing the drive during the flow
         try:
             if mode == "BURN":
                 burn_flow(ser, url)
@@ -3964,12 +4044,14 @@ def station_loop(ser, url, artist_hint=None, album_hint=None):
             _last_burn_result = f"ERROR: {e}"
             print(f"Error in {mode}: {e}")
             time.sleep(4)
+        finally:
+            _operation_active = False
 
         _last_burn_result_time = time.time()
         refresh_main_menu(ser)
 
 
-PIDFILE = "/tmp/discstation.pid"
+PIDFILE = os.path.join(tempfile.gettempdir(), "discstation.pid")
 
 
 def check_pidfile():
@@ -3982,6 +4064,10 @@ def check_pidfile():
                 if sys.platform == "linux":
                     with open(f"/proc/{old_pid}/cmdline") as f:
                         alive = "discstation" in f.read()
+                elif os.name == "nt":
+                    tl = subprocess.run(["tasklist", "/FI", f"PID eq {old_pid}", "/FO", "CSV", "/NH"],
+                                        capture_output=True, text=True)
+                    alive = "python" in tl.stdout.lower()
                 else:
                     ps = subprocess.run(["ps", "-p", str(old_pid), "-o", "command="],
                                         capture_output=True, text=True)