@agentdeck/bridge 1.0.5 → 1.0.7

package/src/idotmatrix/sync.py

@@ -21,6 +21,7 @@ from matrix_sync_common import (  # noqa: E402
     DEFAULT_URL,
     POLL_INTERVAL,
     BRIDGE_GONE_EXIT_SEC,
+    StatusReporter,
     fetch_display_state as _fetch_display_state_sync,
     bridge_reachable as _bridge_reachable_sync,
     resolve_display_brightness as _resolve_display_brightness_common,
@@ -124,7 +125,13 @@ async def run_sync(address: str, url: str, brightness: int = 100, boost: float =
     print(f"AgentDeck Bridge API URL: {url}")
     print(f"Initial Hardware Brightness: {brightness}%")
     print(f"Software Brightness Boost: {boost}x")
-    
+
+    # 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()
+
     manager = ConnectionManager()
     
     idm_image = IdmImage()
@@ -187,8 +194,10 @@ async def run_sync(address: str, url: str, brightness: int = 100, boost: float =
             # 1. Ensure bluetooth connection
             if not connected:
                 print(f"Connecting to iDotMatrix ({address})...")
+                status.connecting()
                 await manager.connectByAddress(address)
                 print("Connected to Bluetooth device!")
+                status.connected()
 
                 # Settle: the panel drops commands sent too soon after the GATT
                 # link comes up. Without this the first setBrightness is lost on a
@@ -227,6 +236,7 @@ async def run_sync(address: str, url: str, brightness: int = 100, boost: float =
             # bleak's is_connected reflects the real OS-level link state.
             if manager.client is None or not manager.client.is_connected:
                 print("BLE link lost — reconnecting...")
+                status.disconnected("BLE link lost")
                 connected = False
                 last_hash = ""
                 await _interruptible_sleep(stop_event, 1.0)
@@ -274,6 +284,7 @@ async def run_sync(address: str, url: str, brightness: int = 100, boost: float =
                 last_brightness_assert = time.monotonic()
 
             if display_dimmed:
+                status.streaming(dimmed=True)
                 await _interruptible_sleep(stop_event, POLL_INTERVAL)
                 continue
 
@@ -302,6 +313,7 @@ async def run_sync(address: str, url: str, brightness: int = 100, boost: float =
             current_hash = hashlib.sha256(frame_data).hexdigest()
             if current_hash == last_hash:
                 # Frame didn't change, skip BLE transmission to save battery and bandwidth
+                status.streaming()
                 await _interruptible_sleep(stop_event, POLL_INTERVAL)
                 continue
                 
@@ -332,8 +344,10 @@ async def run_sync(address: str, url: str, brightness: int = 100, boost: float =
             if res:
                 last_hash = current_hash
                 print("Frame uploaded successfully.")
+                status.frame_sent()
             else:
                 print("Failed to upload frame (uploadUnprocessed returned False).")
+                status.disconnected("frame upload failed")
 
             await _interruptible_sleep(stop_event, POLL_INTERVAL)
 
@@ -343,6 +357,7 @@ async def run_sync(address: str, url: str, brightness: int = 100, boost: float =
         except Exception as e:
             print(f"Error during loop: {e}")
             print("Resetting bluetooth connection...")
+            status.failed(e)
             connected = False
             try:
                 await manager.disconnect()

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: