discstation 0.1.12 → 0.1.14

package/package.json

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

package/src/discstation.py

@@ -23,7 +23,7 @@ import tempfile
 import time
 import datetime
 from pathlib import Path
-from queue import Queue, Empty
+from queue import Queue, Empty, Full
 import http.server
 import socketserver
 try:
@@ -73,6 +73,8 @@ class _WebHandler(http.server.BaseHTTPRequestHandler):
             }), "application/json")
         elif path == '/disc-info':
             self._serve_disc_info()
+        elif path == '/events':
+            self._serve_sse()
         elif path == '/sw.js':
             self._serve_sw()
         elif path == '/manifest.json':
@@ -163,6 +165,38 @@ class _WebHandler(http.server.BaseHTTPRequestHandler):
             print(f"Disc info error: {e}")
         self._respond(200, json.dumps(info), "application/json")
 
+    def _serve_sse(self):
+        """Server-Sent Events stream: pushes status/progress snapshots and a
+        'disc-changed' nudge the moment anything changes. Keepalive comment every
+        15s so proxies don't drop the idle connection."""
+        q = Queue(maxsize=64)
+        with _sse_lock:
+            if len(_sse_subs) >= 32:
+                self.send_error(503)
+                return
+            _sse_subs.add(q)
+        try:
+            self.send_response(200)
+            self.send_header('Content-Type', 'text/event-stream')
+            self.send_header('Cache-Control', 'no-store')
+            self.send_header('X-Accel-Buffering', 'no')
+            self.end_headers()
+            self.wfile.write(b"retry: 3000\n\n")
+            self.wfile.write(("data: " + json.dumps(_status_snapshot()) + "\n\n").encode())
+            self.wfile.flush()
+            while True:
+                try:
+                    payload = q.get(timeout=15)
+                    self.wfile.write(("data: " + payload + "\n\n").encode())
+                except Empty:
+                    self.wfile.write(b": ping\n\n")
+                self.wfile.flush()
+        except (BrokenPipeError, ConnectionResetError, OSError, ValueError):
+            pass
+        finally:
+            with _sse_lock:
+                _sse_subs.discard(q)
+
     def _handle_set_label(self):
         global _last_upload_label
         length = int(self.headers.get('Content-Length', 0))
@@ -178,19 +212,20 @@ class _WebHandler(http.server.BaseHTTPRequestHandler):
     def _serve_sw(self):
         sw = '''self.addEventListener('install', e => {
   self.skipWaiting();
-  caches.open('discstation-v6').then(c => c.addAll(['/','/static/style.css?v=6','/static/app.js?v=6']));
+  caches.open('discstation-v7').then(c => c.addAll(['/','/static/style.css?v=7','/static/app.js?v=7']));
 });
 self.addEventListener('activate', e => e.waitUntil(clients.claim()));
 self.addEventListener('fetch', e => {
   const path = new URL(e.request.url).pathname;
+  if (path === '/events') return;            // never intercept the SSE stream
   if (path === '/' || path.startsWith('/static/')) {
     e.respondWith(fetch(e.request).then(r => {
       const copy = r.clone();
-      caches.open('discstation-v6').then(c => c.put(e.request, copy));
+      caches.open('discstation-v7').then(c => c.put(e.request, copy));
       return r;
     }).catch(() => caches.match(e.request)));
   } else {
-    e.respondWith(caches.match(e.request).then(r => r || fetch(e.request)));
+    e.respondWith(fetch(e.request).catch(() => caches.match(e.request)));
   }
 });'''
         self._respond(200, sw, 'application/javascript')
@@ -300,6 +335,7 @@ def start_web_server(port=8080):
     _web_port = port
     server = socketserver.ThreadingTCPServer(('', port), _WebHandler, bind_and_activate=False)
     server.allow_reuse_address = True
+    server.daemon_threads = True  # don't let an open SSE connection wedge shutdown
     server.server_bind()
     server.server_activate()
 
@@ -326,8 +362,11 @@ def start_web_server(port=8080):
         http_port = 8081
     if http_port and http_port != port:
         try:
-            plain = socketserver.ThreadingTCPServer(('', http_port), _WebHandler)
-            plain.allow_reuse_address = True
+            plain = socketserver.ThreadingTCPServer(('', http_port), _WebHandler, bind_and_activate=False)
+            plain.allow_reuse_address = True  # must be set before bind, or a restart hits TIME_WAIT
+            plain.daemon_threads = True
+            plain.server_bind()
+            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}")
         except OSError as e:
@@ -476,6 +515,25 @@ def ensure_text(value):
     return str(value)
 
 
+# --- Server-Sent Events: push status/progress to browsers the instant it changes
+_sse_subs = set()          # of Queue
+_sse_lock = threading.Lock()
+
+
+def _status_snapshot():
+    return {"status": _web_status or "READY", "progress": _web_progress, "active": _web_progress_active}
+
+
+def _sse_publish(event):
+    payload = json.dumps(event)
+    with _sse_lock:
+        for q in list(_sse_subs):
+            try:
+                q.put_nowait(payload)
+            except Full:
+                _sse_subs.discard(q)
+
+
 def _set_web_progress(phase, percent=-1):
     global _web_status, _web_progress, _web_progress_active
     _web_status = phase
@@ -485,10 +543,14 @@ def _set_web_progress(phase, percent=-1):
         discstation_burn.safe_send(_active_ser, f"STATUS:{phase}")
         if _web_progress >= 0:
             discstation_burn.safe_send(_active_ser, f"PROGRESS:{_web_progress}%")
+    _sse_publish(_status_snapshot())
 
 
 def _record_web_status(msg):
     global _web_status, _web_progress, _web_progress_active
+    if msg.startswith("DISC:"):
+        _sse_publish({"type": "disc-changed"})
+        return
     if msg.startswith("STATUS:"):
         _web_status = msg[7:].strip() or "READY"
         _web_progress_active = True
@@ -509,18 +571,30 @@ def _record_web_status(msg):
     elif msg.startswith("CANCELLED:"):
         _web_status = msg[10:].strip() or "CANCELLED"
         _web_progress_active = 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.
+        text = msg.split(":", 1)[1].strip()
+        _web_status = "READY" if text in ("", "DiscStation", "Select mode", "Starting...") else text
+        _web_progress = -1
+        _web_progress_active = False
+    else:
+        return
+    _sse_publish(_status_snapshot())
 
 
 def send(ser, msg):
-    _record_web_status(msg)
     discstation_burn.send(ser, msg)
 
 
 def safe_send(ser, msg):
-    _record_web_status(msg)
     discstation_burn.safe_send(ser, msg)
 
 
+# Route every serial line the burn/rip pipeline emits into the web/SSE status.
+discstation_burn.status_sink = _record_web_status
+
+
 def run_as_desktop_user(cmd):
     if os.name != "posix" or pwd is None:
         return cmd
@@ -3762,9 +3836,13 @@ def station_loop(ser, url, artist_hint=None, album_hint=None):
                         apply_disc_line("Disc: reading...")
                 elif st == "disc":
                     _tray_open = False
+                    transient_words = ["none", "checking", "reading", "tray open"]
+                    if discstation_host.system_name() == "darwin":
+                        # macOS slot drives take a few seconds to mount; "unknown"
+                        # is a not-ready read, not a settled answer — keep re-polling.
+                        transient_words.append("unknown")
                     have_line = last_disc_line and not any(
-                        w in last_disc_line.lower()
-                        for w in ("none", "checking", "reading", "tray open"))
+                        w in last_disc_line.lower() for w in transient_words)
                     if not have_line and _disc_poll_future is None:
                         _disc_poll_start = now
                         last_disc_poll = now

package/src/discstation_burn.py

@@ -513,8 +513,18 @@ def detect_disc_type(device):
         "capacity": capacity,
     }
 
+# discstation.py sets this to _record_web_status so every serial line the burn
+# pipeline emits also updates the web/SSE status in real time.
+status_sink = None
+
+
 def send(ser, msg):
     global _serial_write_failed
+    if status_sink is not None:
+        try:
+            status_sink(msg)
+        except Exception:
+            pass
     if not ser:
         return False
     try:
@@ -532,6 +542,11 @@ def send(ser, msg):
 
 def safe_send(ser, msg):
     if not ser:
+        if status_sink is not None:
+            try:
+                status_sink(msg)
+            except Exception:
+                pass
         return False
     try:
         return send(ser, msg)

package/src/discstation_host.py

@@ -424,6 +424,7 @@ def eject_device(device, close=False):
             command.append("-t")
         command.append(device)
     elif system == "darwin":
+        global _last_disc_device
         # `drutil tray open` is a no-op on slot-load drives; `drutil eject`
         # works on both. `diskutil eject` is the fallback for a mounted disc.
         if close:
@@ -435,6 +436,10 @@ def eject_device(device, close=False):
         for command in commands:
             try:
                 if subprocess.run(command, capture_output=True, text=True, timeout=10).returncode == 0:
+                    if not close:
+                        # the /dev/diskN node is gone now — don't let disc_device()
+                        # hand back this stale node when the next disc goes in.
+                        _last_disc_device = None
                     return True
             except (OSError, subprocess.TimeoutExpired):
                 pass

package/src/static/app.js

@@ -254,9 +254,34 @@
   setupTabs();
   loadDiscInfo();
   pollStatus();
-  setInterval(pollStatus, 2000);
+  startEventStream();
 
-  if ("serviceWorker" in navigator) navigator.serviceWorker.register("/sw.js?v=4").catch(() => {});
+  function startEventStream() {
+    if (typeof EventSource === "undefined") { setInterval(pollStatus, 2000); return; }
+    let es;
+    try { es = new EventSource("/events"); }
+    catch (_) { setInterval(pollStatus, 2000); return; }
+    es.addEventListener("message", (ev) => {
+      let d;
+      try { d = JSON.parse(ev.data); } catch (_) { return; }
+      if (d.type === "disc-changed") { loadDiscInfo(); return; }
+      setConnection(true);
+      setLiveStatus(d.status);
+      setProgress(d.status, Number(d.progress), d.active);
+    });
+    es.addEventListener("open", () => { setConnection(true); loadDiscInfo(); });
+    es.addEventListener("error", () => {
+      // EventSource reconnects on its own; reflect the gap meanwhile.
+      setConnection(false);
+      setLiveStatus("OFFLINE");
+      setProgress("OFFLINE", -1, false);
+    });
+    // Backstops: catch a zombie SSE connection, and refresh disc state slowly.
+    setInterval(() => { if (!es || es.readyState !== 1) pollStatus(); }, 8000);
+    setInterval(loadDiscInfo, 15000);
+  }
+
+  if ("serviceWorker" in navigator) navigator.serviceWorker.register("/sw.js?v=7").catch(() => {});
   window.addEventListener("beforeinstallprompt", (event) => {
     event.preventDefault();
     const button = document.createElement("button");

package/src/static/index.html

@@ -105,7 +105,7 @@
     </footer>
   </div>
   <div id="install-slot"></div>
-  <script>if ("serviceWorker" in navigator) navigator.serviceWorker.register("/sw.js?v=5").catch(() => {});</script>
-  <script src="/static/app.js?v=5" defer></script>
+  <script>if ("serviceWorker" in navigator) navigator.serviceWorker.register("/sw.js?v=7").catch(() => {});</script>
+  <script src="/static/app.js?v=7" defer></script>
 </body>
 </html>