@agentdeck/bridge 1.0.6 → 1.0.7

package/src/pysync/matrix_sync_common.py

@@ -10,6 +10,7 @@ so this module must stay dependency-free beyond the stdlib.
 """
 
 import json
+import sys
 import urllib.request
 
 DEFAULT_URL = "http://127.0.0.1:9120"
@@ -87,3 +88,85 @@ def resolve_display_brightness(display_state, normal_brightness, *, off_floor, l
     if display_on or not dim_enabled:
         return normal_brightness, False, signature, dim_mode
     return (dim_level if dim_mode == "min" else off_floor), True, signature, dim_mode
+
+
+# ---------------------------------------------------------------------------
+# Link status reporting
+# ---------------------------------------------------------------------------
+
+# Prefix of the machine-readable status lines the daemon supervisor parses.
+# Mirrored in bridge/src/ble-sync-spawn.ts (`BLE_STATUS_LINE_PREFIX`).
+STATUS_LINE_PREFIX = "AGENTDECK_STATUS "
+
+
+class StatusReporter:
+    """Report BLE link state to the daemon that spawned us, one line per change.
+
+    The Node daemon has no BLE of its own: it spawns this client and can only
+    watch the process. But both clients reconnect *inside* their own loop, so a
+    powered-off panel leaves the child running indefinitely and "process alive"
+    says nothing about whether the panel is being driven. Without this signal
+    the daemon's /health could only report the configured device list, and every
+    consumer that renders `connected` — macOS menubar, Dashboard rail, TUI —
+    drew both BLE panels as disconnected while they were streaming.
+
+    Emitting only on *change* keeps the frame loop from flooding the daemon log,
+    and the supervisor keeps these lines out of its diagnostic output ring so a
+    reconnect never looks like a new crash cycle.
+    """
+
+    def __init__(self, emit=None):
+        self._emit = emit if emit is not None else _write_status_line
+        self._last = None
+        # Sticky: once we have painted the panel, our frame is on it even while
+        # the link is down. Matches `hasFrame` in the daemon's health shape.
+        self._has_frame = False
+
+    def _update(self, connected, phase, dimmed=False, error=None):
+        payload = {
+            "connected": bool(connected),
+            "phase": phase,
+            "hasFrame": self._has_frame,
+            "dimmed": bool(dimmed),
+            "error": error,
+        }
+        if payload == self._last:
+            return
+        self._last = payload
+        self._emit(payload)
+
+    def connecting(self):
+        self._update(False, "connecting")
+
+    def connected(self):
+        self._update(True, "connected")
+
+    def streaming(self, dimmed=False):
+        """Link up and the frame loop is running — does not claim a painted frame.
+
+        Used on the dim/pause path, where a reconnect while the host display is
+        already asleep runs the loop without pushing anything.
+        """
+        self._update(True, "streaming", dimmed=dimmed)
+
+    def frame_sent(self, dimmed=False):
+        self._has_frame = True
+        self.streaming(dimmed=dimmed)
+
+    def disconnected(self, error=None):
+        self._update(False, "disconnected", error=error)
+
+    def failed(self, error):
+        self._update(False, "error", error=str(error) if error is not None else None)
+
+
+def _write_status_line(payload):
+    """Write one status line to stdout. Never raises — a closed pipe during
+    shutdown must not take the farewell frame down with it."""
+    try:
+        sys.stdout.write(
+            STATUS_LINE_PREFIX + json.dumps(payload, separators=(",", ":")) + "\n"
+        )
+        sys.stdout.flush()
+    except Exception:
+        pass

package/src/timebox/sync_ble.py

@@ -31,6 +31,7 @@ from matrix_sync_common import (  # noqa: E402
     DEFAULT_URL,
     POLL_INTERVAL,
     BRIDGE_GONE_EXIT_SEC,
+    StatusReporter,
     fetch_display_state,
     bridge_reachable,
     resolve_display_brightness as _resolve_display_brightness_common,
@@ -182,6 +183,11 @@ async def push_micro_frame(client, url, brightness, gamma, sat, contrast, last_k
 
 async def run(address: str, url: str, brightness: int, gamma: float, sat: float, contrast: float, once: bool = False) -> None:
     print(f"Starting Timebox Mini BLE sync: {address} <- {url} brightness={brightness}% gamma={gamma}")
+    # Machine-readable link state for the daemon supervisor — it spawns us but
+    # cannot see the BLE link, and we reconnect inside this loop rather than
+    # exiting, so process liveness tells it nothing about whether the panel is
+    # actually being driven.
+    status = StatusReporter()
     stop = asyncio.Event()
     # Why we're stopping — decides the farewell. 'signal' = clean daemon shutdown
     # (no successor → blank the panel). 'orphan' = parent died (a successor daemon
@@ -238,12 +244,15 @@ async def run(address: str, url: str, brightness: int, gamma: float, sat: float,
             # the inner loop would spin forever on a dead link and the outer reconnect
             # path (below) would never run.
             print("BLE peripheral disconnected — will reconnect.", file=sys.stderr)
+            status.disconnected("BLE peripheral disconnected")
             loop.call_soon_threadsafe(link_lost.set)
 
         try:
             print(f"Connecting BLE {address}...")
+            status.connecting()
             async with BleakClient(address, timeout=15.0, disconnected_callback=on_disconnect) as client:
                 print(f"BLE connected (MTU={client.mtu_size})")
+                status.connected()
 
                 last_key = ""
                 last_sent_at = time.monotonic()
@@ -270,6 +279,7 @@ async def run(address: str, url: str, brightness: int, gamma: float, sat: float,
                     #    on a dead link — only this flag / is_connected reveals it.
                     if link_lost.is_set() or not client.is_connected:
                         print("BLE link lost — reconnecting.", file=sys.stderr)
+                        status.disconnected("BLE link lost")
                         break
                     # 1. Apply host display sleep/wake. The daemon exposes the same
                     #    display_state Pixoo/iDotMatrix/ESP32 receive; older session-
@@ -289,6 +299,7 @@ async def run(address: str, url: str, brightness: int, gamma: float, sat: float,
                     #    brightness on the transition (0 => blank sleep frame), then
                     #    pause polling to save BLE bandwidth (mirrors iDotMatrix).
                     if display_dimmed:
+                        status.streaming(dimmed=True)
                         if transitioned or once:
                             try:
                                 last_key, sent = await push_micro_frame(
@@ -297,9 +308,11 @@ async def run(address: str, url: str, brightness: int, gamma: float, sat: float,
                                 if sent:
                                     last_sent_at = time.monotonic()
                                 last_bridge_ok = time.monotonic()
+                                status.frame_sent(dimmed=True)
                             except Exception as e:
                                 print(f"Dim-frame send error: {e}", file=sys.stderr)
                                 if link_lost.is_set() or not client.is_connected:
+                                    status.disconnected(f"dim-frame send error: {e}")
                                     break
                         if once:
                             return
@@ -321,6 +334,7 @@ async def run(address: str, url: str, brightness: int, gamma: float, sat: float,
                         if sent:
                             last_sent_at = time.monotonic()
                         last_bridge_ok = time.monotonic()
+                        status.frame_sent()
                     except Exception as e:
                         print(f"Frame fetch/send error: {e}", file=sys.stderr)
                         # A write error after the link dropped must escalate to a
@@ -328,6 +342,7 @@ async def run(address: str, url: str, brightness: int, gamma: float, sat: float,
                         # not — keep streaming and let should_exit() handle a truly
                         # gone bridge.
                         if link_lost.is_set() or not client.is_connected:
+                            status.disconnected(f"frame send error: {e}")
                             break
                     if once:
                         return
@@ -364,6 +379,7 @@ async def run(address: str, url: str, brightness: int, gamma: float, sat: float,
                         print(f"Farewell blank failed: {e}", file=sys.stderr)
         except Exception as e:
             print(f"BLE connection error: {e}", file=sys.stderr)
+            status.failed(f"BLE connection error: {e}")
             if once:
                 raise
             try: