feat: unified fleet telemetry — canonical format, GPS/IP geo, WAN health dashboard

- Rewrite telemetry-synology.sh: canonical GL format (modem_0001/wan keys),
  self-contained metrics (no aiwanbal), Eyeride GPS with IP geo fallback
- Add /api/fleet-telemetry to hub: joins tunnel status with fleet Postgres
- Update dashboard.html: per-device WAN health bars, GPS, signal strength
- Fix hub/ingest.sh normalisation: remap old wan1/wan2 → modem_0001/wan
- Bump SPK version: 0.1-0001 → 0.5.0-0001 for GL parity

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

hub/dashboard.html

@@ -23,18 +23,36 @@ body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
 .stat-card .lbl { font-size: 10px; color: var(--dim); text-transform: uppercase; margin-top: 2px; }
 .stat-card .num.online { color: var(--green); }
 .stat-card .num.offline { color: var(--red); }
-.grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(400px, 1fr)); gap: 16px; }
+.grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(420px, 1fr)); gap: 16px; }
 .card { background: var(--card); border: 1px solid var(--border); border-radius: 8px; padding: 16px; }
-.card h2 { font-size: 16px; margin-bottom: 12px; display: flex; justify-content: space-between; align-items: center; }
+.card h2 { font-size: 16px; margin-bottom: 8px; display: flex; justify-content: space-between; align-items: center; }
 .badge { font-size: 11px; padding: 2px 8px; border-radius: 12px; font-weight: 600; }
 .badge-gl { background: rgba(88,166,255,0.15); color: var(--blue); }
 .badge-synology { background: rgba(210,153,34,0.15); color: var(--amber); }
+.badge-ver { background: rgba(139,148,158,0.15); color: var(--dim); font-size: 10px; }
 .dot { display: inline-block; width: 8px; height: 8px; border-radius: 50%; margin-right: 4px; }
 .dot-up { background: var(--green); }
 .dot-down { background: var(--red); }
-.row { display: flex; justify-content: space-between; padding: 5px 0; font-size: 13px; border-bottom: 1px solid rgba(255,255,255,0.04); }
+.row { display: flex; justify-content: space-between; padding: 4px 0; font-size: 13px; border-bottom: 1px solid rgba(255,255,255,0.04); }
 .row .label { color: var(--dim); }
 .row .val { font-family: monospace; font-size: 12px; }
+.wan-section { margin-top: 8px; padding-top: 8px; border-top: 1px solid var(--border); }
+.wan-section .title { font-size: 11px; color: var(--dim); text-transform: uppercase; letter-spacing: 1px; margin-bottom: 6px; }
+.wan-bar { display: flex; align-items: center; gap: 8px; margin-bottom: 4px; font-size: 12px; }
+.wan-bar .member { font-family: monospace; min-width: 90px; font-size: 11px; }
+.wan-bar .score { font-weight: 700; min-width: 32px; text-align: right; }
+.wan-bar .score.good { color: var(--green); }
+.wan-bar .score.warn { color: var(--amber); }
+.wan-bar .score.bad { color: var(--red); }
+.wan-bar .metric { color: var(--dim); font-size: 11px; }
+.wan-bar .signal { font-size: 10px; }
+.wan-bar .signal.good { color: var(--green); }
+.wan-bar .signal.warn { color: var(--amber); }
+.wan-bar .signal.bad { color: var(--red); }
+.active-dot { display: inline-block; width: 6px; height: 6px; border-radius: 50%; background: var(--green); margin-right: 4px; flex-shrink: 0; }
+.gps-line { font-size: 11px; color: var(--dim); margin-top: 4px; }
+.gps-line a { color: var(--blue); text-decoration: none; }
+.gps-line a:hover { text-decoration: underline; }
 .access { margin-top: 12px; padding-top: 12px; border-top: 1px solid var(--border); }
 .access .title { font-size: 11px; color: var(--dim); text-transform: uppercase; letter-spacing: 1px; margin-bottom: 8px; }
 .cmd { background: #0d1117; padding: 6px 10px; border-radius: 4px; font-family: monospace;
@@ -43,6 +61,7 @@ body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
 .cmd a:hover { text-decoration: underline; }
 .empty { color: var(--dim); text-align: center; padding: 60px 20px; font-size: 14px; }
 .refresh { color: var(--dim); font-size: 11px; text-align: right; margin-top: 20px; }
+.telem-warn { font-size: 10px; color: var(--amber); margin-left: 8px; }
 </style>
 </head>
 <body>
@@ -59,8 +78,8 @@ body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
 var HUB = window.location.origin;
 
 function loadFleet() {
-    fetch(HUB + '/api/fleet')
-        .then(function(r) { return r.ok ? r.json() : Promise.reject(r.status); })
+    fetch(HUB + '/api/fleet-telemetry')
+        .then(function(r) { return r.ok ? r.json() : fetch(HUB + '/api/fleet').then(function(r2) { return r2.json(); }); })
         .then(function(data) { render(data); })
         .catch(function(e) {
             document.getElementById('fleet').innerHTML =
@@ -69,18 +88,55 @@ function loadFleet() {
     document.getElementById('refresh').textContent = 'Last updated: ' + new Date().toLocaleTimeString();
 }
 
+function scoreClass(s) {
+    if (s == null) return '';
+    if (s >= 70) return 'good';
+    if (s >= 40) return 'warn';
+    return 'bad';
+}
+
+function signalClass(rsrp) {
+    if (rsrp == null) return '';
+    if (rsrp >= -85) return 'good';
+    if (rsrp >= -105) return 'warn';
+    return 'bad';
+}
+
+function signalBars(rsrp) {
+    if (rsrp == null) return '—';
+    if (rsrp >= -85) return '▂▄▆█';
+    if (rsrp >= -95) return '▂▄▆_';
+    if (rsrp >= -105) return '▂▄__';
+    if (rsrp >= -115) return '▂___';
+    return '____';
+}
+
+function fmtLatency(ms) { return ms != null ? ms + ' ms' : '—'; }
+function fmtLoss(pct) { return pct != null ? pct + '%' : '—'; }
+function fmtScore(s) { return s != null ? s : '—'; }
+function fmtUptime(s) {
+    if (s == null) return '—';
+    var h = Math.floor(s / 3600);
+    var m = Math.floor((s % 3600) / 60);
+    if (h >= 24) { var d = Math.floor(h / 24); return d + 'd ' + (h % 24) + 'h'; }
+    return h + 'h ' + m + 'm';
+}
+
 function render(data) {
     var devices = data.devices || [];
     var online = devices.filter(function(d) { return d.tunnel_up; }).length;
+    var telemOnline = data.telemetry_online || 0;
 
     document.getElementById('stats').innerHTML =
         '<div class="stat-card"><div class="num">' + devices.length +
         '</div><div class="lbl">Registered</div></div>' +
         '<div class="stat-card"><div class="num online">' + online +
-        '</div><div class="lbl">Online</div></div>' +
+        '</div><div class="lbl">Tunnel Online</div></div>' +
         '<div class="stat-card"><div class="num offline">' + (devices.length - online) +
-        '</div><div class="lbl">Offline</div></div>' +
-        '<div class="stat-card"><div class="num">' + (data.hub || '') +
+        '</div><div class="lbl">Tunnel Offline</div></div>' +
+        '<div class="stat-card"><div class="num" style="font-size:20px">' + telemOnline +
+        '</div><div class="lbl">Telemetry Active</div></div>' +
+        '<div class="stat-card"><div class="num" style="font-size:18px">' + (data.hub || '') +
         '</div><div class="lbl">Hub</div></div>';
 
     var el = document.getElementById('fleet');
@@ -90,21 +146,62 @@ function render(data) {
     }
 
     el.innerHTML = devices.map(function(d) {
-        var isSynology = d.device_id.startsWith('x');
+        var isSynology = d.platform === 'synology' || d.device_id.startsWith('x');
         var badge = isSynology
             ? '<span class="badge badge-synology">Synology</span>'
             : '<span class="badge badge-gl">GL-XE3000</span>';
+        var verBadge = d.version ? '<span class="badge badge-ver">v' + esc(d.version) + '</span>' : '';
         var status = d.tunnel_up
             ? '<span><span class="dot dot-up"></span>ONLINE</span>'
             : '<span><span class="dot dot-down"></span>OFFLINE</span>';
+        var telemWarn = d.tunnel_up && !d.online_telemetry
+            ? '<span class="telem-warn">(no telemetry)</span>' : '';
 
         var ssh = 'ssh -p ' + d.tunnel_port + ' kitadmin@' + data.hub;
         var web = d.dashboard_url;
 
+        // WAN health bars
+        var wanHtml = '';
+        var wans = d.wan_summary || [];
+        if (wans.length) {
+            wanHtml = '<div class="wan-section"><div class="title">WAN Health</div>';
+            for (var i = 0; i < wans.length; i++) {
+                var w = wans[i];
+                var activeMarker = w.active ? '<span class="active-dot"></span>' : '<span style="display:inline-block;width:6px;margin-right:4px"></span>';
+                var bars = signalBars(w.rsrp_dbm);
+                wanHtml += '<div class="wan-bar">' +
+                    activeMarker +
+                    '<span class="member">' + esc(w.member) + '</span>' +
+                    '<span class="score ' + scoreClass(w.score) + '">' + fmtScore(w.score) + '</span>' +
+                    '<span class="metric">' + fmtLatency(w.latency_ms) + ' / ' + fmtLoss(w.loss_pct) + ' loss</span>' +
+                    (w.rsrp_dbm != null
+                        ? '<span class="signal ' + signalClass(w.rsrp_dbm) + '" title="RSRP: ' + w.rsrp_dbm + ' dBm">' + bars + ' ' + w.rsrp_dbm + ' dBm</span>'
+                        : '') +
+                    (w.carrier ? '<span class="metric" style="margin-left:4px">' + esc(w.carrier) + '</span>' : '') +
+                    (w.technology && w.technology !== 'unknown' ? '<span class="metric">' + esc(w.technology) + '</span>' : '') +
+                    '</div>';
+            }
+            wanHtml += '</div>';
+        }
+
+        // GPS line
+        var gpsHtml = '';
+        if (d.gps && d.gps.lat != null && d.gps.lon != null) {
+            var fixLabel = d.gps.fix === 1 ? ' (IP approx)' : (d.gps.fix >= 2 ? ' (GPS)' : '');
+            gpsHtml = '<div class="gps-line">📍 ' +
+                Number(d.gps.lat).toFixed(4) + ', ' + Number(d.gps.lon).toFixed(4) + fixLabel +
+                ' — <a href="https://maps.google.com/?q=' + d.gps.lat + ',' + d.gps.lon + '" target="_blank">Google Maps</a>' +
+                '</div>';
+        }
+
         return '<div class="card">' +
-            '<h2>' + esc(d.device_id) + ' ' + badge + ' <span style="font-size:13px">' + status + '</span></h2>' +
+            '<h2>' + esc(d.device_id) + ' ' + badge + verBadge + ' <span style="font-size:13px">' + status + telemWarn + '</span></h2>' +
             '<div class="row"><span class="label">Tunnel Port</span><span class="val">' + d.tunnel_port + '</span></div>' +
             '<div class="row"><span class="label">Assigned</span><span class="val">' + (d.assigned || '--') + '</span></div>' +
+            (d.uptime_s ? '<div class="row"><span class="label">Uptime</span><span class="val">' + fmtUptime(d.uptime_s) + '</span></div>' : '') +
+            (d.autonomous != null ? '<div class="row"><span class="label">Autonomous</span><span class="val">' + (d.autonomous ? '✅ Enabled' : '❌ Disabled') + '</span></div>' : '') +
+            wanHtml +
+            gpsHtml +
             (d.tunnel_up
                 ? '<div class="access">' +
                   '<div class="title">Direct Access</div>' +

hub/ingest.sh

@@ -18,23 +18,31 @@ mkdir -p "$TELEM_DIR" "$BACKUP_DIR"
 
 # ── Normalise telemetry ────────────────────────────────────────────
 # Both platforms POST to /api/telemetry.
-# GL uses: modem_0001/wan keys, no "platform" field
-# Synology uses: wan1/wan2 keys, "platform":"synology"
-# Output: unified schema with platform field + wan1/wan2 keys
+# Canonical format uses modem_0001/wan keys (matching GL standard).
+# Handles three variants:
+#   - GL (no platform field): add platform="openwrt", pass through
+#   - GL (platform="openwrt"): already canonical, pass through
+#   - Old Synology (platform="synology" + wan1/wan2): remap to modem_0001/wan
+#   - New unified Synology (platform="synology" + modem_0001/wan): pass through
 normalise_telemetry() {
-    local json="$1"
-    local platform=""
+    json="$1"
+    platform=""
 
     platform=$(echo "$json" | grep -o '"platform":"[^"]*"' | cut -d'"' -f4)
     if [ -z "$platform" ]; then
-        # Pre-unified GL telemetry — add platform, remap keys
+        # Pre-unified GL telemetry — add platform field, keys already canonical
         platform="openwrt"
         json=$(echo "$json" | sed \
-            -e 's/"modem_0001"/"wan1"/g' \
-            -e 's/"platform":"openwrt"/"platform":"'"$platform"'"/')
+            -e 's/^{/{"platform":"'"$platform"'",/')
+    fi
+
+    # Remap old Synology wan1/wan2 keys to canonical modem_0001/wan
+    if echo "$json" | grep -q '"wan1"'; then
+        json=$(echo "$json" | sed \
+            -e 's/"wan1"/"modem_0001"/g' \
+            -e 's/"wan2"/"wan"/g')
     fi
 
-    # Ensure both wan1 and wan2 keys exist (Synology uses wan1/wan2 natively)
     echo "$json"
 }
 

hub/server.py

@@ -7,6 +7,8 @@ Listens on :8080. Routes:
   GET  /api/register/<DEVICE_ID>     — assign tunnel port, return JSON
   GET  /api/fleet                    — all registered devices with
                                         tunnel status + access links
+  GET  /api/fleet-telemetry          — fleet status enriched with telemetry
+                                        from fleet Postgres (WAN health, GPS)
   POST /api/authorize-key            — authorize device tunnel key
 """
 
@@ -22,6 +24,13 @@ REGISTRY    = "/opt/busfleet-hub/port-registry.json"
 DASHBOARD   = "/opt/busfleet-hub/dashboard.html"
 HUB_IP      = "162.243.83.36"
 
+# Fleet Postgres connection (for telemetry enrichment)
+FLEET_DB_HOST = os.environ.get("FLEET_DB_HOST", "167.172.237.162")
+FLEET_DB_PORT = os.environ.get("FLEET_DB_PORT", "5432")
+FLEET_DB_NAME = os.environ.get("FLEET_DB_NAME", "fleet")
+FLEET_DB_USER = os.environ.get("FLEET_DB_USER", "fleet")
+FLEET_DB_PASS = os.environ.get("FLEET_DB_PASS", "")
+
 
 # ── Helper: check if a TCP port is open (tunnel active) ──────────
 def _port_is_open(port):
@@ -33,6 +42,84 @@ def _port_is_open(port):
         return False
 
 
+# ── Helper: query fleet Postgres for latest device_status ─────────
+def _query_fleet_telemetry():
+    """Query fleet Postgres for the latest telemetry data for all devices.
+    Returns a dict keyed by device_id, or empty dict if DB unreachable."""
+    try:
+        import psycopg2
+        conn = psycopg2.connect(
+            host=FLEET_DB_HOST,
+            port=FLEET_DB_PORT,
+            dbname=FLEET_DB_NAME,
+            user=FLEET_DB_USER,
+            password=FLEET_DB_PASS,
+            connect_timeout=5,
+        )
+        cur = conn.cursor()
+        cur.execute("""
+            SELECT d.device_id, d.vendor, d.model,
+                   st.online, st.ts, st.version, st.uptime_s,
+                   st.primary_member, st.active_wan,
+                   st.gps_lat, st.gps_lon, st.gps_fix,
+                   st.wan, st.starlink, st.state
+            FROM devices d
+            LEFT JOIN device_status st ON st.device_id = d.device_id
+            ORDER BY d.device_id
+        """)
+        rows = cur.fetchall()
+        cur.close()
+        conn.close()
+
+        result = {}
+        for row in rows:
+            device_id = row[0]
+            wan_data = row[12] if row[12] else {}
+            # psycopg2 returns JSONB as dict
+            if isinstance(wan_data, str):
+                try:
+                    wan_data = json.loads(wan_data)
+                except (json.JSONDecodeError, TypeError):
+                    wan_data = {}
+
+            starlink_data = row[13] if row[13] else {}
+            if isinstance(starlink_data, str):
+                try:
+                    starlink_data = json.loads(starlink_data)
+                except (json.JSONDecodeError, TypeError):
+                    starlink_data = {}
+
+            state_data = row[14] if row[14] else {}
+            if isinstance(state_data, str):
+                try:
+                    state_data = json.loads(state_data)
+                except (json.JSONDecodeError, TypeError):
+                    state_data = {}
+
+            result[device_id] = {
+                "vendor": row[1],
+                "model": row[2],
+                "online": row[3] if row[3] is not None else False,
+                "ts": str(row[4]) if row[4] else None,
+                "version": row[5],
+                "uptime_s": row[6],
+                "primary_member": row[7],
+                "active_wan": row[8],
+                "gps": {
+                    "lat": float(row[9]) if row[9] is not None else None,
+                    "lon": float(row[10]) if row[10] is not None else None,
+                    "fix": row[11],
+                },
+                "wan": wan_data,
+                "starlink": starlink_data,
+                "state": state_data,
+            }
+        return result
+    except Exception as e:
+        print(f"[hub] fleet telemetry query failed: {e}", file=sys.stderr)
+        return {}
+
+
 class HubHandler(BaseHTTPRequestHandler):
     """Handle hub registration, fleet status, and dashboard requests."""
 
@@ -56,11 +143,16 @@ class HubHandler(BaseHTTPRequestHandler):
             self.call_register_script(device_id)
             return
 
-        # Fleet status — all registered devices
+        # Fleet status — basic tunnel-only (original endpoint)
         if self.path == "/api/fleet":
             self.serve_fleet_status()
             return
 
+        # Fleet status — enriched with telemetry from fleet DB
+        if self.path == "/api/fleet-telemetry":
+            self.serve_fleet_telemetry()
+            return
+
         self.send_json_error(404, "Not found")
 
     def do_POST(self):
@@ -161,6 +253,73 @@ class HubHandler(BaseHTTPRequestHandler):
             "devices": devices,
         }))
 
+    def serve_fleet_telemetry(self):
+        """Build enriched fleet status: tunnel status + telemetry from fleet DB."""
+        # Read port registry (tunnel info)
+        try:
+            with open(REGISTRY) as f:
+                registry = json.load(f)
+        except Exception:
+            registry = {}
+
+        # Query fleet Postgres for telemetry
+        fleet_data = _query_fleet_telemetry()
+
+        devices = []
+        for dev_id, entry in registry.items():
+            port = entry.get("tunnel_port", 0)
+            tunnel_up = _port_is_open(port) if port else False
+
+            # Enrich with fleet telemetry
+            telem = fleet_data.get(dev_id, {})
+
+            # Derive platform from vendor or device_id prefix
+            vendor = telem.get("vendor", "")
+            if vendor == "synology" or dev_id.startswith("x"):
+                platform = "synology"
+            elif vendor == "glinet" or dev_id.startswith(("B", "C")):
+                platform = "openwrt"
+            else:
+                platform = telem.get("vendor", "unknown")
+
+            # Format WAN summary for dashboard
+            wan_summary = _format_wan_summary(telem.get("wan", {}), telem.get("primary_member"))
+
+            devices.append({
+                "device_id": dev_id,
+                "tunnel_port": port,
+                "assigned": entry.get("assigned", ""),
+                "tunnel_up": tunnel_up,
+                "ssh_command": f"ssh -p {port} kitadmin@{HUB_IP}",
+                "dashboard_url": f"http://{HUB_IP}:{port}" if tunnel_up else None,
+                # Telemetry enrichment
+                "platform": platform,
+                "version": telem.get("version"),
+                "uptime_s": telem.get("uptime_s"),
+                "online_telemetry": telem.get("online", False),
+                "primary_member": telem.get("primary_member"),
+                "active_wan": telem.get("active_wan"),
+                "gps": telem.get("gps", {}),
+                "wan_summary": wan_summary,
+                "starlink": telem.get("starlink"),
+                "autonomous": telem.get("state", {}).get("autonomous"),
+            })
+
+        # Sort: tunnel_up first, then by device_id
+        devices.sort(key=lambda d: (not d["tunnel_up"], d["device_id"]))
+
+        # Summary stats
+        online = sum(1 for d in devices if d["tunnel_up"])
+        telemetry_online = sum(1 for d in devices if d.get("online_telemetry"))
+
+        self.send_json(200, json.dumps({
+            "hub": HUB_IP,
+            "device_count": len(devices),
+            "online": online,
+            "telemetry_online": telemetry_online,
+            "devices": devices,
+        }))
+
     def send_json(self, status, body):
         """Send a JSON response."""
         self.send_response(status)
@@ -177,6 +336,30 @@ class HubHandler(BaseHTTPRequestHandler):
         print(f"[hub] {args[0]}", file=sys.stderr)
 
 
+def _format_wan_summary(wan, primary_member):
+    """Format WAN data into a concise summary for the dashboard."""
+    if not wan or not isinstance(wan, dict):
+        return []
+    summary = []
+    for member, metrics in wan.items():
+        if not isinstance(metrics, dict):
+            continue
+        entry = {
+            "member": member,
+            "active": member == primary_member,
+            "score": metrics.get("score"),
+            "latency_ms": metrics.get("latency_ms"),
+            "loss_pct": metrics.get("loss_pct"),
+            "rsrp_dbm": metrics.get("rsrp_dbm"),
+            "carrier": metrics.get("carrier"),
+            "technology": metrics.get("technology"),
+        }
+        summary.append(entry)
+    # Sort: active first, then by score descending
+    summary.sort(key=lambda x: (not x["active"], -(x["score"] or 0)))
+    return summary
+
+
 def main():
     port = int(sys.argv[1]) if len(sys.argv) > 1 else 8080
     server = HTTPServer(("0.0.0.0", port), HubHandler)