@bian-womp/spark-remote 0.2.49 → 0.2.51

package/lib/esm/index.js

@@ -21,22 +21,23 @@ class SeqGenerator {
 
 const OPEN = 1;
 class WebSocketTransport {
-    constructor(url) {
+    constructor(url, options) {
         this.listeners = new Set();
         this.seq = new SeqGenerator();
+        this.isAlive = false;
+        this.PING_INTERVAL_MS = 30000;
+        this.PONG_TIMEOUT_MS = 10000;
         this.baseUrl = url;
+        this.onConnectionLost = options?.onConnectionLost;
     }
     async connect(options) {
         if (this.ws && this.ws.readyState === OPEN)
             return;
-        // Build URL with connection params
-        // Handle both ws:///wss:// URLs and http:///https:// URLs (convert to ws)
         let url;
         if (this.baseUrl.startsWith("ws://") || this.baseUrl.startsWith("wss://")) {
             url = new URL(this.baseUrl);
         }
         else {
-            // Convert http/https to ws/wss
             const wsBaseUrl = this.baseUrl.replace(/^http/, "ws");
             url = new URL(wsBaseUrl);
         }
@@ -54,7 +55,10 @@ class WebSocketTransport {
         await new Promise((resolve, reject) => {
             if (!this.ws)
                 return reject(new Error("ws init failed"));
-            this.ws.onopen = () => resolve();
+            this.ws.onopen = () => {
+                this.startHeartbeat();
+                resolve();
+            };
             this.ws.onerror = (e) => reject(e);
             this.ws.onmessage = (ev) => {
                 try {
@@ -64,10 +68,72 @@ class WebSocketTransport {
                 }
                 catch { }
             };
+            this.ws.onclose = () => {
+                this.stopHeartbeat();
+            };
         });
     }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.isAlive = true;
+        if (typeof window !== "undefined" || !this.ws)
+            return;
+        this.pongHandler = () => {
+            this.isAlive = true;
+            if (this.pongTimeout) {
+                clearTimeout(this.pongTimeout);
+                this.pongTimeout = undefined;
+            }
+        };
+        this.ws.on("pong", this.pongHandler);
+        this.pingInterval = setInterval(() => {
+            if (!this.ws || this.ws.readyState !== OPEN) {
+                this.stopHeartbeat();
+                return;
+            }
+            if (!this.isAlive) {
+                this.onConnectionLost?.();
+                this.stopHeartbeat();
+                this.ws.terminate();
+                return;
+            }
+            this.isAlive = false;
+            try {
+                this.ws.ping();
+            }
+            catch (err) {
+                console.warn("[WebSocketTransport] Failed to send ping:", err);
+                this.onConnectionLost?.();
+                this.stopHeartbeat();
+                return;
+            }
+            this.pongTimeout = setTimeout(() => {
+                if (!this.isAlive) {
+                    this.onConnectionLost?.();
+                    this.stopHeartbeat();
+                    if (this.ws) {
+                        this.ws.terminate();
+                    }
+                }
+            }, this.PONG_TIMEOUT_MS);
+        }, this.PING_INTERVAL_MS);
+    }
+    stopHeartbeat() {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = undefined;
+        }
+        if (this.pongTimeout) {
+            clearTimeout(this.pongTimeout);
+            this.pongTimeout = undefined;
+        }
+        if (this.ws && this.pongHandler) {
+            this.ws.off("pong", this.pongHandler);
+            this.pongHandler = undefined;
+        }
+        this.isAlive = false;
+    }
     async request(msg) {
-        // For now, just send and wait for the next message with matching seq (simple demo)
         const seq = this.seq.next();
         const env = { ...msg, seq };
         const p = new Promise((resolve) => {
@@ -91,6 +157,7 @@ class WebSocketTransport {
         return () => this.listeners.delete(cb);
     }
     async close() {
+        this.stopHeartbeat();
         if (!this.ws)
             return;
         const ws = this.ws;
@@ -416,15 +483,6 @@ async function createRuntimeAdapter(createRegistry, send, extensions) {
             }
             graphRuntime.setEnvironment(env);
         },
-        setInput: (nodeId, handle, value) => {
-            // If engine exists, use it; otherwise fall back to direct runtime access
-            if (engine) {
-                engine.setInput(nodeId, handle, value);
-            }
-            else {
-                graphRuntime?.setInput(nodeId, handle, value);
-            }
-        },
         setInputs: (nodeId, inputs) => {
             if (engine) {
                 engine.setInputs(nodeId, inputs);
@@ -524,9 +582,11 @@ async function createRuntimeAdapter(createRegistry, send, extensions) {
         describeRegistry: wrapMethod("describeRegistry", originalApi.describeRegistry),
         update: wrapMethod("update", originalApi.update),
         setEnvironment: wrapMethod("setEnvironment", originalApi.setEnvironment),
-        setInput: wrapMethod("setInput", originalApi.setInput),
         setInputs: wrapMethod("setInputs", originalApi.setInputs),
         triggerExternal: wrapMethod("triggerExternal", originalApi.triggerExternal),
+        step: wrapMethod("step", originalApi.step),
+        computeNode: wrapMethod("computeNode", originalApi.computeNode),
+        flush: wrapMethod("flush", originalApi.flush),
         launch: wrapMethod("launch", originalApi.launch),
         whenIdle: wrapMethod("whenIdle", originalApi.whenIdle),
         dispose: wrapMethod("dispose", originalApi.dispose),
@@ -571,11 +631,6 @@ class RemoteEngine {
             },
         });
     }
-    setInput(nodeId, handle, value) {
-        this.transport.send({
-            message: { type: "SetInput", payload: { nodeId, handle, value } },
-        });
-    }
     // Batch inputs for a single network round-trip
     setInputs(nodeId, inputs) {
         this.transport.send({
@@ -734,7 +789,13 @@ class RuntimeApiClient {
             if (!WebSocketTransport) {
                 throw new Error("WebSocketTransport not available");
             }
-            return new WebSocketTransport(this.config.url);
+            return new WebSocketTransport(this.config.url, {
+                onConnectionLost: () => {
+                    this.dispose().catch((err) => {
+                        console.warn("[RuntimeApiClient] Error disposing on connection loss:", err);
+                    });
+                },
+            });
         }
         else if (kind === "remote-unix") {
             // Dynamic import to avoid bundling in browser builds
@@ -1091,16 +1152,6 @@ class RuntimeApiServer {
                 ack();
                 break;
             }
-            case "SetInput": {
-                this.logCommand("SetInput", env, {
-                    nodeId: msg.payload.nodeId,
-                    handle: msg.payload.handle,
-                    value: summarize(msg.payload.value),
-                });
-                this.runtimeApi.setInput(msg.payload.nodeId, msg.payload.handle, msg.payload.value);
-                ack();
-                break;
-            }
             case "SetInputs": {
                 this.logCommand("SetInputs", env, {
                     nodeId: msg.payload.nodeId,
@@ -1219,12 +1270,6 @@ class RuntimeApiServer {
                 ack();
                 break;
             }
-            case "Pause":
-            case "Resume": {
-                this.logCommand(`${msg.type} (not-impl)`, env);
-                ack();
-                break;
-            }
             default: {
                 this.logCommand("Unknown type", env);
                 ack();