hypha-rpc 0.20.57 → 0.20.59

package/dist/hypha-rpc-websocket.js

@@ -941,8 +941,8 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
           timer.clear();
         }
         if (clear_after_called && self._object_store[session_id]) {
-          // console.log("Deleting session", session_id, "from", self._client_id);
-          delete self._object_store[session_id];
+          // Simple cleanup - let the session manager handle the logic
+          self._cleanup_session_if_needed(session_id, name);
         }
       }
     };
@@ -950,6 +950,47 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
     return [encoded, wrapped_callback];
   }
 
+  // Clean session management - all logic in one place
+  _cleanup_session_if_needed(session_id, callback_name) {
+    const store = this._get_session_store(session_id, false);
+    if (!store) return;
+
+    // Promise sessions: let the promise manager decide cleanup
+    if (store._promise_manager) {
+      if (store._promise_manager.should_cleanup_on_callback(callback_name)) {
+        store._promise_manager.settle();
+        delete this._object_store[session_id];
+      }
+      return;
+    }
+
+    // Regular sessions: cleanup immediately
+    delete this._object_store[session_id];
+  }
+
+  // Clean helper to identify promise method calls by session type
+  _is_promise_method_call(method_path) {
+    const session_id = method_path.split(".")[0];
+    const session = this._get_session_store(session_id, false);
+    return session && session._promise_manager;
+  }
+
+  // Clean Promise Manager - encapsulates all promise lifecycle logic
+  _create_promise_manager() {
+    return {
+      settled: false,
+      settle() {
+        this.settled = true;
+      },
+      is_settled() {
+        return this.settled;
+      },
+      should_cleanup_on_callback(callback_name) {
+        return callback_name === "resolve" || callback_name === "reject";
+      },
+    };
+  }
+
   async _encode_promise(
     resolve,
     reject,
@@ -960,12 +1001,17 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
     description,
   ) {
     let store = this._get_session_store(session_id, true);
-    (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(
-      store,
-      `Failed to create session store ${session_id} due to invalid parent`,
-    );
+    if (!store) {
+      console.warn(
+        `Failed to create session store ${session_id}, session management may be impaired`,
+      );
+      store = {};
+    }
     let encoded = {};
 
+    // Clean promise lifecycle management
+    store._promise_manager = this._create_promise_manager();
+
     if (timer && reject && this._method_timeout) {
       [encoded.heartbeat, store.heartbeat] = this._encode_callback(
         "heartbeat",
@@ -974,12 +1020,9 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
         false,
         null,
         local_workspace,
-        // `heartbeat (${description})`,
       );
       store.timer = timer;
       encoded.interval = this._method_timeout / 2;
-    } else {
-      timer = null;
     }
 
     [encoded.resolve, store.resolve] = this._encode_callback(
@@ -1043,7 +1086,19 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       }
 
       // Wait for all chunk uploads to finish
-      await Promise.all(tasks);
+      try {
+        await Promise.all(tasks);
+      } catch (error) {
+        // If any chunk fails, clean up the message cache
+        try {
+          await message_cache.remove(message_id);
+        } catch (cleanupError) {
+          console.error(
+            `Failed to clean up message cache after error: ${cleanupError}`,
+          );
+        }
+        throw error;
+      }
     } else {
       // 3) Legacy version (sequential appends):
       await message_cache.create(message_id, !!session_id);
@@ -1181,13 +1236,24 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
           );
           // By default, hypha will clear the session after the method is called
           // However, if the args contains _rintf === true, we will not clear the session
-          let clear_after_called = true;
-          for (let arg of args) {
-            if (typeof arg === "object" && arg._rintf === true) {
-              clear_after_called = false;
-              break;
+
+          // Helper function to recursively check for _rintf objects
+          function hasInterfaceObject(obj) {
+            if (!obj || typeof obj !== "object") return false;
+            if (obj._rintf === true) return true;
+            if (Array.isArray(obj)) {
+              return obj.some((item) => hasInterfaceObject(item));
             }
+            if (obj.constructor === Object) {
+              return Object.values(obj).some((value) =>
+                hasInterfaceObject(value),
+              );
+            }
+            return false;
           }
+
+          let clear_after_called = !hasInterfaceObject(args);
+
           const promiseData = await self._encode_promise(
             resolve,
             reject,
@@ -1344,7 +1410,14 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       try {
         method = indexObject(this._object_store, data["method"]);
       } catch (e) {
-        // console.debug("Failed to find method", method_name, this._client_id, e);
+        // Clean promise method error handling
+        if (this._is_promise_method_call(data["method"])) {
+          console.debug(
+            `Promise method ${data["method"]} not available (session settled or cleaned up), ignoring: ${method_name}`,
+          );
+          return;
+        }
+
         throw new Error(
           `Method not found: ${method_name} at ${this._client_id}`,
         );
@@ -1478,7 +1551,8 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       const last_index = levels.length - 1;
       for (let level of levels.slice(0, last_index)) {
         if (!store[level]) {
-          return null;
+          // Instead of returning null, create intermediate sessions as needed
+          store[level] = {};
         }
         store = store[level];
       }
@@ -1692,6 +1766,9 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       nj.NdArray &&
       aObject instanceof nj.NdArray
     ) {
+      if (!aObject.selection || !aObject.selection.data) {
+        throw new Error("Invalid NumJS array: missing selection or data");
+      }
       const dtype = (0,_utils__WEBPACK_IMPORTED_MODULE_0__.typedArrayToDtype)(aObject.selection.data);
       bObject = {
         _rtype: "ndarray",
@@ -1784,10 +1861,7 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
           local_workspace,
         ),
       };
-    } else if (
-      aObject.constructor instanceof Object ||
-      Array.isArray(aObject)
-    ) {
+    } else if (aObject.constructor === Object || Array.isArray(aObject)) {
       bObject = isarray ? [] : {};
       const keys = Object.keys(aObject);
       for (let k of keys) {
@@ -1861,23 +1935,18 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
 
         // Create an async generator proxy
         async function* asyncGeneratorProxy() {
-          try {
-            while (true) {
-              try {
-                const next_item = await gen_method();
-                // Check for StopIteration signal
-                if (next_item && next_item._rtype === "stop_iteration") {
-                  break;
-                }
-                yield next_item;
-              } catch (error) {
-                console.error("Error in generator:", error);
-                throw error;
+          while (true) {
+            try {
+              const next_item = await gen_method();
+              // Check for StopIteration signal
+              if (next_item && next_item._rtype === "stop_iteration") {
+                break;
               }
+              yield next_item;
+            } catch (error) {
+              console.error("Error in generator:", error);
+              throw error;
             }
-          } catch (error) {
-            console.error("Error in generator:", error);
-            throw error;
           }
         }
         bObject = asyncGeneratorProxy();
@@ -2791,6 +2860,21 @@ async function _createOffer(params, server, config, onInit, context) {
   let answer = await pc.createAnswer();
   await pc.setLocalDescription(answer);
 
+  // Wait for ICE candidates to be gathered (important for Firefox)
+  await new Promise((resolveIce) => {
+    if (pc.iceGatheringState === "complete") {
+      resolveIce();
+    } else {
+      pc.addEventListener("icegatheringstatechange", () => {
+        if (pc.iceGatheringState === "complete") {
+          resolveIce();
+        }
+      });
+      // Don't wait forever for ICE gathering
+      setTimeout(resolveIce, 5000);
+    }
+  });
+
   return {
     sdp: pc.localDescription.sdp,
     type: pc.localDescription.type,
@@ -2810,30 +2894,80 @@ async function getRTCService(server, service_id, config) {
   });
 
   return new Promise(async (resolve, reject) => {
+    let resolved = false;
+    const timeout = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        pc.close();
+        reject(new Error("WebRTC Connection timeout"));
+      }
+    }, 30000); // Increase timeout to 30 seconds
+
     try {
       pc.addEventListener(
         "connectionstatechange",
         () => {
+          console.log("WebRTC Connection state: ", pc.connectionState);
           if (pc.connectionState === "failed") {
-            pc.close();
-            reject(new Error("WebRTC Connection failed"));
+            if (!resolved) {
+              resolved = true;
+              clearTimeout(timeout);
+              pc.close();
+              reject(new Error("WebRTC Connection failed"));
+            }
           } else if (pc.connectionState === "closed") {
-            reject(new Error("WebRTC Connection closed"));
-          } else {
-            console.log("WebRTC Connection state: ", pc.connectionState);
+            if (!resolved) {
+              resolved = true;
+              clearTimeout(timeout);
+              reject(new Error("WebRTC Connection closed"));
+            }
+          } else if (pc.connectionState === "connected") {
+            console.log("WebRTC Connection established successfully");
           }
         },
         false,
       );
 
+      // Add ICE connection state change handler for better debugging
+      pc.addEventListener("iceconnectionstatechange", () => {
+        console.log("ICE Connection state: ", pc.iceConnectionState);
+        if (pc.iceConnectionState === "failed") {
+          if (!resolved) {
+            resolved = true;
+            clearTimeout(timeout);
+            pc.close();
+            reject(new Error("ICE Connection failed"));
+          }
+        }
+      });
+
       if (config.on_init) {
         await config.on_init(pc);
         delete config.on_init;
       }
+
       let channel = pc.createDataChannel(config.peer_id, { ordered: true });
       channel.binaryType = "arraybuffer";
+
+      // Wait for ICE gathering to complete before creating offer
       const offer = await pc.createOffer();
       await pc.setLocalDescription(offer);
+
+      // Wait for ICE candidates to be gathered (important for Firefox)
+      await new Promise((resolveIce) => {
+        if (pc.iceGatheringState === "complete") {
+          resolveIce();
+        } else {
+          pc.addEventListener("icegatheringstatechange", () => {
+            if (pc.iceGatheringState === "complete") {
+              resolveIce();
+            }
+          });
+          // Don't wait forever for ICE gathering
+          setTimeout(resolveIce, 5000);
+        }
+      });
+
       const svc = await server.getService(service_id);
       const answer = await svc.offer({
         sdp: pc.localDescription.sdp,
@@ -2843,77 +2977,102 @@ async function getRTCService(server, service_id, config) {
       channel.onopen = () => {
         config.channel = channel;
         config.workspace = answer.workspace;
-        // Wait for the channel to be open before returning the rpc
-        // This is needed for safari to work
+        // Increase timeout for Firefox compatibility
         setTimeout(async () => {
-          const rpc = await _setupRPC(config);
-          pc.rpc = rpc;
-          async function get_service(name, ...args) {
-            (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(
-              !name.includes(":"),
-              "WebRTC service name should not contain ':'",
-            );
-            (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(
-              !name.includes("/"),
-              "WebRTC service name should not contain '/'",
-            );
-            return await rpc.get_remote_service(
-              config.workspace + "/" + config.peer_id + ":" + name,
-              ...args,
-            );
-          }
-          async function disconnect() {
-            await rpc.disconnect();
-            pc.close();
-          }
-          pc.getService = (0,_utils_schema_js__WEBPACK_IMPORTED_MODULE_2__.schemaFunction)(get_service, {
-            name: "getService",
-            description: "Get a remote service via webrtc",
-            parameters: {
-              type: "object",
-              properties: {
-                service_id: {
-                  type: "string",
-                  description:
-                    "Service ID. This should be a service id in the format: 'workspace/service_id', 'workspace/client_id:service_id' or 'workspace/client_id:service_id@app_id'",
-                },
-                config: {
+          if (!resolved) {
+            try {
+              const rpc = await _setupRPC(config);
+              pc.rpc = rpc;
+              async function get_service(name, ...args) {
+                (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(
+                  !name.includes(":"),
+                  "WebRTC service name should not contain ':'",
+                );
+                (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(
+                  !name.includes("/"),
+                  "WebRTC service name should not contain '/'",
+                );
+                return await rpc.get_remote_service(
+                  config.workspace + "/" + config.peer_id + ":" + name,
+                  ...args,
+                );
+              }
+              async function disconnect() {
+                await rpc.disconnect();
+                pc.close();
+              }
+              pc.getService = (0,_utils_schema_js__WEBPACK_IMPORTED_MODULE_2__.schemaFunction)(get_service, {
+                name: "getService",
+                description: "Get a remote service via webrtc",
+                parameters: {
                   type: "object",
-                  description: "Options for the service",
+                  properties: {
+                    service_id: {
+                      type: "string",
+                      description:
+                        "Service ID. This should be a service id in the format: 'workspace/service_id', 'workspace/client_id:service_id' or 'workspace/client_id:service_id@app_id'",
+                    },
+                    config: {
+                      type: "object",
+                      description: "Options for the service",
+                    },
+                  },
+                  required: ["id"],
                 },
-              },
-              required: ["id"],
-            },
-          });
-          pc.disconnect = (0,_utils_schema_js__WEBPACK_IMPORTED_MODULE_2__.schemaFunction)(disconnect, {
-            name: "disconnect",
-            description: "Disconnect from the webrtc connection via webrtc",
-            parameters: { type: "object", properties: {} },
-          });
-          pc.registerCodec = (0,_utils_schema_js__WEBPACK_IMPORTED_MODULE_2__.schemaFunction)(rpc.register_codec, {
-            name: "registerCodec",
-            description: "Register a codec for the webrtc connection",
-            parameters: {
-              type: "object",
-              properties: {
-                codec: {
+              });
+              pc.disconnect = (0,_utils_schema_js__WEBPACK_IMPORTED_MODULE_2__.schemaFunction)(disconnect, {
+                name: "disconnect",
+                description: "Disconnect from the webrtc connection via webrtc",
+                parameters: { type: "object", properties: {} },
+              });
+              pc.registerCodec = (0,_utils_schema_js__WEBPACK_IMPORTED_MODULE_2__.schemaFunction)(rpc.register_codec, {
+                name: "registerCodec",
+                description: "Register a codec for the webrtc connection",
+                parameters: {
                   type: "object",
-                  description: "Codec to register",
                   properties: {
-                    name: { type: "string" },
-                    type: {},
-                    encoder: { type: "function" },
-                    decoder: { type: "function" },
+                    codec: {
+                      type: "object",
+                      description: "Codec to register",
+                      properties: {
+                        name: { type: "string" },
+                        type: {},
+                        encoder: { type: "function" },
+                        decoder: { type: "function" },
+                      },
+                    },
                   },
                 },
-              },
-            },
-          });
-          resolve(pc);
-        }, 500);
+              });
+              resolved = true;
+              clearTimeout(timeout);
+              resolve(pc);
+            } catch (e) {
+              if (!resolved) {
+                resolved = true;
+                clearTimeout(timeout);
+                reject(e);
+              }
+            }
+          }
+        }, 1000); // Increase timeout to 1 second for Firefox
       };
 
-      channel.onclose = () => reject(new Error("Data channel closed"));
+      channel.onclose = () => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timeout);
+          reject(new Error("Data channel closed"));
+        }
+      };
+
+      channel.onerror = (error) => {
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timeout);
+          reject(new Error(`Data channel error: ${error}`));
+        }
+      };
 
       await pc.setRemoteDescription(
         new RTCSessionDescription({
@@ -2922,7 +3081,11 @@ async function getRTCService(server, service_id, config) {
         }),
       );
     } catch (e) {
-      reject(e);
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timeout);
+        reject(e);
+      }
     }
   });
 }