discstation 0.1.9 → 0.1.10

package/package.json

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

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

@@ -295,12 +295,16 @@ def can_use_linux_optical_backend():
 
 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 +314,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")