discstation 0.1.11 → 0.1.13

package/README.md

@@ -47,9 +47,16 @@ playback, ripping, phone uploads, and ESP32 remote control.
 
 ```bash
 npm install -g discstation
-discstation-setup          # dispatches to the installer for your OS
+discstation-setup          # dispatches to the installer for your OS, then opens the UI
 ```
 
+The host runs as a background service; the UI is the built-in web app at
+`http://localhost:8081`. `discstation-setup` opens it when it finishes, and the
+`discstation` command re-opens it any time. It's a PWA — use your browser's
+**Install DiscStation** (or the in-page **INSTALL APP** button on Chromium) to
+get a standalone app window with a dock/taskbar icon on macOS, Linux, and
+Windows.
+
 `discstation-setup --help` lists the forwarded env vars. From a git clone,
 `npm run setup` does the same thing. Support by OS:
 

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "discstation",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "DiscStation optical-media appliance host — one cross-OS installer",
   "bin": {
-    "discstation-setup": "scripts/setup.mjs"
+    "discstation-setup": "scripts/setup.mjs",
+    "discstation": "scripts/open.mjs"
   },
   "scripts": {
     "setup": "node scripts/setup.mjs"

package/scripts/open.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+// `discstation` — open the local web UI in the default browser.
+// The UI is a PWA: once open, use the browser's "Install DiscStation" (or the
+// in-page INSTALL APP button on Chromium) to get a standalone app window.
+
+import { spawn } from 'node:child_process';
+import { get } from 'node:http';
+
+const port = process.env.DISCSTATION_HTTP_PORT || '8081';
+const url = process.argv[2] || `http://localhost:${port}/`;
+
+function open(target) {
+  const [cmd, args] =
+    process.platform === 'darwin' ? ['open', [target]]
+    : process.platform === 'win32' ? ['cmd', ['/c', 'start', '', target]]
+    : ['xdg-open', [target]];
+  const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
+  child.on('error', () => {
+    console.log(`Open this in your browser:\n  ${target}`);
+  });
+  child.unref();
+}
+
+// Best-effort liveness check so a stopped host gives a clear hint.
+const probe = get(url, { timeout: 1500 }, (res) => {
+  res.resume();
+  open(url);
+});
+probe.on('timeout', () => probe.destroy());
+probe.on('error', () => {
+  console.log(
+    `DiscStation host isn't answering on ${url}\n` +
+    `Start it with "discstation-setup" (first run) or check the service:\n` +
+    `  linux:  systemctl --user status discstation.service\n` +
+    `  macOS:  launchctl print gui/$(id -u)/com.discstation.agent`,
+  );
+  open(url);
+});

package/scripts/setup.mjs

@@ -28,6 +28,9 @@ Linux script uses sudo for apt + group membership.
 Env vars (forwarded): DISCSTATION_APP_DIR, DISCSTATION_VENV_DIR,
 DISCSTATION_CONFIG_DIR, DISCSTATION_HTTP_PORT, DISC_DEVICE, DISC_PORT.
 
+On success it opens the web UI (a PWA — install it from the browser for an app
+window). Re-open it any time with the "discstation" command.
+
 Any extra arguments are passed straight to the platform script.
 `
   );
@@ -40,6 +43,15 @@ function run(cmd, cmdArgs) {
     console.error(`\n${cmd}: ${r.error.message}`);
     process.exit(1);
   }
+  if ((r.status ?? 1) === 0) {
+    const port = process.env.DISCSTATION_HTTP_PORT || '8081';
+    console.log(
+      `\nDiscStation is installed and running.\n` +
+      `  Web UI:  http://localhost:${port}/   (run "discstation" to open it any time)\n` +
+      `  Install it as an app from the browser menu, or the in-page INSTALL APP button.\n`,
+    );
+    spawnSync(process.execPath, [join(ROOT, 'scripts', 'open.mjs')], { stdio: 'ignore' });
+  }
   process.exit(r.status ?? 1);
 }
 

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,23 @@ def _record_web_status(msg):
     elif msg.startswith("CANCELLED:"):
         _web_status = msg[10:].strip() or "CANCELLED"
         _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

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/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>