discstation 0.1.9 → 0.1.11

package/README.md

@@ -17,23 +17,27 @@ playback, ripping, phone uploads, and ESP32 remote control.
 | **Burn Data DVD** | Any files/folders → ISO/Joliet data disc (no quality loss) |
 | **Burn MPG** | Re-burn a previously converted movie.mpg |
 | **Play** | Playback via mpv (DVD-Video, Audio CD, VCD, SVCD) |
-| **Rip** | Audio CD → FLAC with MusicBrainz metadata |
+| **Rip** | Audio CD → FLAC (MusicBrainz); DVD-Video → VIDEO_TS mirror or HandBrake MKV (TMDb naming) |
 
 ## Project Structure
 
 ```
 .
 ├── src/
-│   ├── discstation.py    # Main orchestrator, serial, web server
-│   └── discstation_burn.py       # Burn pipeline (download, convert, author, burn)
+│   ├── discstation.py        # Main orchestrator, serial, web server
+│   ├── discstation_burn.py   # Burn pipeline (download, convert, author, burn)
+│   ├── discstation_host.py   # Per-OS device/path/backend abstraction
+│   ├── discstation_meta.py   # TMDb video metadata
+│   └── static/               # Built-in web UI (index.html, app.js, style.css)
+├── mobile/                   # Expo (React Native) companion app
 ├── arduino/
-│   ├── c6/               # ESP32-C6 firmware
-│   └── v1/               # ESP32 DevKit firmware
-├── docs/                 # Platform support notes
-├── install.sh            # Linux host installer
-├── install-macos.sh      # macOS host bootstrap
-├── install-windows.ps1   # Windows host bootstrap
-├── systemd/              # Linux auto-start unit
+│   ├── c6/                   # ESP32-C6 firmware
+│   └── v1/                   # ESP32 DevKit firmware
+├── scripts/setup.mjs         # `discstation-setup` — cross-OS installer dispatch
+├── docs/                     # Platform support notes
+├── install.sh / install-macos.sh / install-windows.ps1
+├── requirements.txt / requirements-optional.txt
+├── systemd/                  # Linux auto-start unit
 └── README.md
 ```
 
@@ -52,7 +56,7 @@ discstation-setup          # dispatches to the installer for your OS
 | OS | What runs | Optical support |
 |----|-----------|-----------------|
 | 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 | experimental (set `DISC_DEVICE` if detection fails) |
+| 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 |
 
 ### Or run the platform script directly
@@ -75,9 +79,10 @@ PowerShell -ExecutionPolicy Bypass -File .\install-windows.ps1
 
 ## Platform Support
 
-Linux currently supports the complete optical workflow. macOS and Windows use
-the shared Python/web workflows, but their native optical burning backends are
-still being implemented. See `docs/PLATFORM_SUPPORT.md`.
+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`.
 
 ## Web Interface
 
@@ -102,6 +107,11 @@ 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_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 |
+| `DISC_AUDIO_DEVICE` | auto | mpv audio-output device override |
 
 ### YouTube Download Configuration
 

package/docs/PLATFORM_SUPPORT.md

@@ -9,16 +9,23 @@ Run `./install.sh` on Debian, Ubuntu, or Raspberry Pi OS.
 
 ## macOS
 
-The Python host and web/control workflow run with Homebrew dependencies. Data
-and DVD image burning use `hdiutil`; DVD-Video discs can be mounted read-only
-for playback and VIDEO_TS ripping; audio CD burning uses cdrdao. Optical-device
-discovery and video/audio workflows are experimental; use `DISC_DEVICE`
-when automatic detection does not find the external drive. Apple Music owns
-audio CD playback and ripping on macOS, so DiscStation does not probe or access
-audio tracks for those operations. Audio burns include CD-TEXT from the source
-folder/file name and track metadata. Apple Music may still show generic track
-names when its online CD lookup has no match; CD-TEXT-capable players can read
-the embedded names. The macOS installer installs a persistent `launchd` service.
+Near-complete native support via Homebrew dependencies (`install-macos.sh`
+installs them and a persistent `launchd` agent):
+
+- **Detect** — optical device via `ioreg` / `drutil` / `diskutil`; blank and
+  rewritable media are classified, so the OLED offers the burn menu.
+- **Burn** — data and DVD-Video images are built with `xorriso -as mkisofs`
+  (`-dvd-video` for a set-top-compatible VIDEO_TS layout) and written with
+  `hdiutil burn` (progress streamed from its `-puppetstrings` output).
+- **Rip** — audio CD via `cd-paranoia` → FLAC with MusicBrainz metadata and
+  cover art; DVD-Video via `dvdbackup -M` (or HandBrake main-feature with
+  `DISCSTATION_DVD_RIP_MODE=mkv`), `libdvdcss` handling CSS.
+- **Play** — `mpv`, with `dvdnav://` menu navigation for DVD-Video and a
+  mounted-VOB fallback.
+
+Set `DISC_DEVICE` if automatic drive detection fails. The one known limitation
+is **audio-CD *burning*** — `cdrdao` is the only option and often cannot claim
+the drive on recent macOS; DiscStation reports this clearly instead of hanging.
 
 ## Windows
 
@@ -32,8 +39,8 @@ instead of silently attempting Linux commands.
 - DiscStation workflows and web UI
 - ESP32 serial protocol
 - File upload and folder preservation
-- Video/audio metadata handling
+- Video/audio metadata handling (MusicBrainz, TMDb)
 - QR-code web URL display
 
-The optical-drive backend is the platform boundary. It should be completed per
-OS before claiming full native burning support on that platform.
+The optical-drive backend is the platform boundary. Linux and macOS are
+complete (bar macOS audio-CD burning); Windows still needs its writer backend.

package/package.json

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

package/scripts/setup.mjs

@@ -18,7 +18,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 (optical is experimental)
+  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
 
 Prereqs: Node 16+, Python 3 (python3 / py on PATH), and either bash (linux/macOS)

package/src/discstation.py

@@ -2933,15 +2933,16 @@ def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None):
         pass
 
     env = os.environ.copy()
-    if "DISPLAY" not in env:
-        env["DISPLAY"] = ":0"
-    try:
-        uid = os.getuid()
-        home_xauth = Path.home() / ".Xauthority"
-        env.setdefault("XAUTHORITY", str(home_xauth) if home_xauth.exists() else f"/run/user/{uid}/.Xauthority")
-        env.setdefault("XDG_RUNTIME_DIR", f"/run/user/{uid}")
-    except Exception:
-        pass
+    if discstation_host.system_name() == "linux":
+        if "DISPLAY" not in env:
+            env["DISPLAY"] = ":0"
+        try:
+            uid = os.getuid()
+            home_xauth = Path.home() / ".Xauthority"
+            env.setdefault("XAUTHORITY", str(home_xauth) if home_xauth.exists() else f"/run/user/{uid}/.Xauthority")
+            env.setdefault("XDG_RUNTIME_DIR", f"/run/user/{uid}")
+        except Exception:
+            pass
 
     proc = subprocess.Popen(run_as_desktop_user(cmd), env=env)
 
@@ -3082,23 +3083,36 @@ def play_flow(ser):
 
     if kind == "dvd_video":
         if discstation_host.system_name() == "darwin":
-            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")
+            try:
                 cmd = [
                     "mpv",
                     "--input-ipc-server=" + MPV_SOCKET,
                     "--force-window=yes",
                     "--idle=no",
-                    *[str(path) for path in files],
+                    "--dvd-device=" + rip_device(device),
+                    "dvdnav://",
                 ]
                 _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)
         else:
             cmd = [
                 "mpv",
@@ -3880,10 +3894,16 @@ def check_pidfile():
                 old_pid = int(f.read().strip())
             try:
                 os.kill(old_pid, 0)
-                with open(f"/proc/{old_pid}/cmdline") as f:
-                    if "discstation" in f.read():
-                        print(f"Already running (PID {old_pid}), exiting")
-                        sys.exit(0)
+                if sys.platform == "linux":
+                    with open(f"/proc/{old_pid}/cmdline") as f:
+                        alive = "discstation" in f.read()
+                else:
+                    ps = subprocess.run(["ps", "-p", str(old_pid), "-o", "command="],
+                                        capture_output=True, text=True)
+                    alive = "discstation" in ps.stdout
+                if alive:
+                    print(f"Already running (PID {old_pid}), exiting")
+                    sys.exit(0)
             except (OSError, IOError):
                 pass
     except (ValueError, OSError):

package/src/discstation_burn.py

@@ -121,6 +121,12 @@ def reset_drive(device=None):
     """Power-cycle the USB optical enclosure by toggling its sysfs 'authorized'
     flag (or via DISCSTATION_USB_RESET_CMD). Best-effort; returns True on a
     completed toggle/hook, False otherwise."""
+    if discstation_host.system_name() == "darwin":
+        # ponytail: no USB re-enumeration on macOS; an eject/reload is the only
+        # soft reset available and it drops whatever disc is loaded.
+        for cmd in (["/usr/bin/drutil", "eject"], ["/usr/bin/drutil", "tray", "close"]):
+            subprocess.run(cmd, capture_output=True, timeout=15, check=False)
+        return True
     if discstation_host.system_name() != "linux":
         return False
     if not device:
@@ -1251,6 +1257,38 @@ def _run_growisofs(ser, growisofs_cmd, log_path, device=None):
         print(f"Disc eject skipped: {e}")
 
 
+def _run_hdiutil_burn(ser, image_path, device=None):
+    """Burn a pre-built ISO on macOS via `hdiutil burn -puppetstrings`, streaming
+    its PERCENT: lines to the ESP32."""
+    send(ser, "STATUS:Burning image...")
+    send(ser, "PROGRESS:0%")
+    cmd = discstation_host.iso_burn_command(device or disc_device(), image_path)
+    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+    out_lines = []
+    last_pct = -1
+    try:
+        for line in iter_proc_or_cancel(proc, ser):
+            out_lines.append(line)
+            m = re.search(r"PERCENT:([\d.]+)", line)
+            if m:
+                pct = int(float(m.group(1)))
+                if 0 <= pct <= 100 and pct != last_pct:
+                    last_pct = pct
+                    send(ser, f"PROGRESS:{min(pct, 99)}%")
+    except (KeyboardInterrupt, SystemExit):
+        stop_process(proc)
+        raise
+    rc = proc.wait()
+    if rc != 0:
+        detail = next((l for l in reversed(out_lines) if l.strip()), "hdiutil burn failed")
+        raise RuntimeError(f"Disc burn failed: {detail[:120]}")
+    safe_send(ser, "PROGRESS:100%")
+    try:
+        discstation_host.eject_device(device or disc_device())
+    except Exception as e:
+        print(f"Disc eject skipped: {e}")
+
+
 def burn(ser, dvd_dir, disc_label, speed=None, is_dual_layer=False):
     if discstation_host.system_name() != "linux":
         WORK.mkdir(parents=True, exist_ok=True)
@@ -1403,8 +1441,15 @@ def burn_audio_cd(ser, audio_files, disc_label, speed=None):
     # 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).
+    try:
+        cdrdao_write_dev = discstation_host.cdrdao_device(disc_device())
+    except RuntimeError:
+        if discstation_host.system_name() == "darwin":
+            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', discstation_host.cdrdao_device(disc_device())]
+                  '--device', cdrdao_write_dev]
     driver = os.environ.get("DISCSTATION_CDRDAO_DRIVER", "generic-mmc-raw")
     if driver:
         cdrdao_cmd += ['--driver', driver]
@@ -1454,6 +1499,9 @@ def burn_audio_cd(ser, audio_files, disc_label, speed=None):
 
 def burn_iso(ser, iso_path, speed=None, is_dual_layer=False):
     """Burn a pre-built ISO directly to disc — no filesystem building."""
+    if discstation_host.system_name() == "darwin":
+        _run_hdiutil_burn(ser, iso_path)
+        return
     if discstation_host.system_name() != "linux":
         send(ser, "STATUS:Burning image...")
         _run_growisofs(ser, discstation_host.iso_burn_command(disc_device(), iso_path), iso_path.parent / "discstation-burn.log")
@@ -1493,8 +1541,9 @@ def remux_and_author(ser, mpg, disc_label, disc_capacity, dvd_aspect=None):
     send(ser, f"INFO:Burning {mpg.parent.name}")
 
     send(ser, "STATUS:Remuxing to fix timestamps...")
-    v_es = Path(f"/tmp/video_{os.getpid()}.m2v")
-    a_es = Path(f"/tmp/audio_{os.getpid()}.ac3")
+    WORK.mkdir(parents=True, exist_ok=True)
+    v_es = WORK / f"video_{os.getpid()}.m2v"
+    a_es = WORK / f"audio_{os.getpid()}.ac3"
     fixed = mpg.parent / "movie_fixed.mpg"
     if fixed.exists():
         fixed.unlink()

package/src/discstation_host.py

@@ -289,18 +289,18 @@ def null_device():
     return "NUL" if system_name() == "windows" else "/dev/null"
 
 
-def can_use_linux_optical_backend():
-    return system_name() == "linux" and all(shutil.which(name) for name in ("growisofs", "wodim", "cdrdao"))
-
-
 def build_data_image(source_paths, output_path, label, video=False):
     system = system_name()
-    if system == "darwin":
-        command = [tool("hdiutil"), "makehybrid", "-o", str(output_path), "-iso", "-joliet", "-udf"]
-        command += ["-default-volume-name", label, *[str(path) for path in source_paths]]
-    elif system == "windows":
-        command = [tool("xorriso"), "-as", "mkisofs", "-iso-level", "3", "-J", "-R", "-V", label, "-o", str(output_path)]
-        command += [str(path) for path in source_paths]
+    if system in ("darwin", "windows"):
+        # xorriso's mkisofs emulation is the same lineage as Linux's
+        # genisoimage/growisofs; -dvd-video gives a set-top-compatible
+        # VIDEO_TS layout (the arg is the dir *containing* VIDEO_TS).
+        command = [tool("xorriso"), "-as", "mkisofs", "-V", label, "-o", str(output_path)]
+        if video:
+            command += ["-dvd-video", "-udf", str(source_paths[0])]
+        else:
+            command += ["-iso-level", "3", "-J", "-R", "-udf",
+                        *[str(path) for path in source_paths]]
     else:
         raise RuntimeError("Image building is only used by non-Linux optical backends")
     subprocess.run(command, check=True, capture_output=True, text=True)
@@ -310,7 +310,8 @@ def build_data_image(source_paths, output_path, label, video=False):
 def iso_burn_command(device, image_path):
     system = system_name()
     if system == "darwin":
-        return [tool("hdiutil"), "burn", str(image_path)]
+        # -puppetstrings emits machine-readable PERCENT: / MESSAGE: lines.
+        return [tool("hdiutil"), "burn", "-puppetstrings", str(image_path)]
     if system == "windows":
         return [tool("isoburn.exe"), "/Q", device, str(image_path)]
     raise RuntimeError("ISO command requested on Linux; use growisofs backend")