signalk-edge-link 2.6.2 → 2.6.3

package/lib/index.js

@@ -209,6 +209,23 @@ module.exports = function createPlugin(app) {
             setStatus(`Startup failed: ${startError instanceof Error ? startError.message : String(startError)}`);
             return;
         }
+        // Wire up FULL_STATUS_REQUEST cascade: when a client-mode instance receives
+        // a FULL_STATUS_REQUEST from its upstream server, it should also forward the
+        // request to all downstream clients connected to any co-located server-mode
+        // instances. This propagates the request down the chain (Cloud → Proxy → Boat)
+        // so one-shot startup values from the furthest-downstream node are re-sent.
+        const allStarted = [...instances.values()];
+        const serverInsts = allStarted.filter((inst) => inst.isServerMode());
+        const clientInsts = allStarted.filter((inst) => !inst.isServerMode());
+        if (serverInsts.length > 0 && clientInsts.length > 0) {
+            for (const clientInst of clientInsts) {
+                clientInst.setFullStatusCascadeHandler(() => {
+                    for (const serverInst of serverInsts) {
+                        serverInst.requestFullStatusFromAllClients();
+                    }
+                });
+            }
+        }
         // Initial status aggregation after all instances report their status
         updateAggregatedStatus();
     };

package/lib/instance.js

@@ -379,6 +379,12 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
     /** Minimum gap between server-initiated full-status replays. Prevents a
      *  restarting or misconfigured server from flooding the link. */
     const FULL_STATUS_REQUEST_RATE_LIMIT_MS = 10000;
+    /**
+     * Optional callback invoked after this (client-mode) instance handles a
+     * FULL_STATUS_REQUEST. Used in multi-hop chains to cascade the request to
+     * any downstream clients connected to a co-located server-mode instance.
+     */
+    let fullStatusCascadeHandler = null;
     /** Server asked for a full values snapshot (FULL_STATUS_REQUEST control
      *  packet). Replays the entire current Signal K tree to the server.
      *  Rate-limited to prevent replay floods across rapid server restarts. */
@@ -391,6 +397,10 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
         state.lastFullStatusRequestAt = now;
         app.debug(`[${instanceId}] FULL_STATUS_REQUEST received — replaying values snapshot`);
         replayValuesSnapshot("full-status-request");
+        if (fullStatusCascadeHandler) {
+            app.debug(`[${instanceId}] FULL_STATUS_REQUEST cascading to downstream clients`);
+            fullStatusCascadeHandler();
+        }
     }
     async function sendSourceSnapshot() {
         if (state.stopped ||
@@ -1291,6 +1301,16 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
         getName: () => state.instanceName,
         getStatus: () => ({ text: state.instanceStatus, healthy: state.isHealthy }),
         getState: () => state,
-        getMetricsApi: () => metricsApi
+        getMetricsApi: () => metricsApi,
+        /** Register a callback to invoke when this client-mode instance handles
+         *  a FULL_STATUS_REQUEST, so the request cascades to downstream clients. */
+        setFullStatusCascadeHandler(handler) {
+            fullStatusCascadeHandler = handler;
+        },
+        /** Forward a FULL_STATUS_REQUEST to all currently-connected clients
+         *  (server-mode instances only; no-op on client-mode instances). */
+        requestFullStatusFromAllClients() {
+            state.pipelineServer?.requestFullStatusFromAllClients?.();
+        }
     };
 }

package/lib/pipeline-v2-server.js

@@ -717,6 +717,20 @@ function createPipelineV2Server(app, state, metricsApi) {
             throw err;
         }
     }
+    /**
+     * Send FULL_STATUS_REQUEST to every currently-connected client session.
+     * Called when this server instance itself receives a FULL_STATUS_REQUEST
+     * from an upstream server, so the request cascades down the chain:
+     * Cloud → Proxy (triggers this) → Boat.
+     */
+    function requestFullStatusFromAllClients() {
+        const secretKey = state.options?.secretKey ?? "";
+        for (const session of clientSessions.values()) {
+            _sendFullStatusRequest(session, secretKey).catch((err) => {
+                app.debug(`[v2-server] cascade FULL_STATUS_REQUEST to ${session.key} failed: ${err instanceof Error ? err.message : String(err)}`);
+            });
+        }
+    }
     /**
      * Build and send a META_REQUEST (0x07) control packet to a client.
      * Instructs the client to emit a fresh metadata snapshot — used on first
@@ -1210,6 +1224,7 @@ function createPipelineV2Server(app, state, metricsApi) {
         startACKTimer,
         stopACKTimer,
         startMetricsPublishing,
-        stopMetricsPublishing
+        stopMetricsPublishing,
+        requestFullStatusFromAllClients
     };
 }

package/lib/values-snapshot.js

@@ -171,18 +171,28 @@ function collectValuesSnapshot(app) {
             }
             const context = `${contextGroup}.${contextId}`;
             walkValues(contextNode, [], (leaf) => {
-                // Skip values that this plugin injected from remote instances.
-                // SK stores them under "signalk-edge-link.*" $source keys. Including
-                // them in the snapshot would loop remote data back to its origin and
-                // propagate wrong source labels (the fallback label derived from the
-                // "signalk-edge-link" prefix is never the original sensor label).
-                // Live streaming handles relay correctly via subscription callbacks,
-                // which SK populates with the full source object automatically.
+                // Values stored under "signalk-edge-link.*" $source keys were injected
+                // by this plugin (data received via an upstream edge-link server connection
+                // or a downstream edge-link client connection). Skip them only when the SK
+                // sources table cannot provide a proper original-sensor label — that case
+                // would produce wrong attribution on the receiver. When the sources table
+                // does resolve to a real label (e.g. "pypilot"), include the value so relay
+                // data reaches the upstream server after its restart; the receiver's
+                // normalizeDeltaSourceRefs will strip the stale $source and
+                // handleMessageBySource will dispatch under the original label.
                 const src = leaf.source ?? "";
                 if (src === "signalk-edge-link" ||
                     src.startsWith("signalk-edge-link.") ||
                     src.startsWith("signalk-edge-link:")) {
-                    return;
+                    const resolved = sourceLookup.get(src);
+                    const resolvedLabel = typeof resolved?.label === "string" ? resolved.label.trim() : "";
+                    if (!resolvedLabel ||
+                        resolvedLabel === "signalk-edge-link" ||
+                        resolvedLabel.startsWith("signalk-edge-link.") ||
+                        resolvedLabel.startsWith("signalk-edge-link:")) {
+                        return; // No proper label available — skip to avoid wrong attribution
+                    }
+                    // Resolved to a real sensor label — fall through and include the value
                 }
                 const key = `${context}|${leaf.source ?? ""}|${leaf.timestamp}`;
                 const existing = grouped.get(key);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-edge-link",
-  "version": "2.6.2",
+  "version": "2.6.3",
   "description": "SignalK Edge Link. Secure UDP link for data exchange.",
   "main": "lib/index.js",
   "files": [