hypha-rpc 0.20.85 → 0.20.87

package/dist/hypha-rpc-websocket.js

@@ -51,6 +51,31 @@ function _appendBuffer(buffer1, buffer2) {
   return tmp.buffer;
 }
 
+/**
+ * Wrap a promise with a timeout.
+ * @param {Promise} promise - The promise to wrap.
+ * @param {number} timeoutMs - The timeout in milliseconds.
+ * @param {string} message - Optional error message for timeout.
+ * @returns {Promise} - The wrapped promise that will reject on timeout.
+ */
+function withTimeout(promise, timeoutMs, message = "Operation timed out") {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new Error(`TimeoutError: ${message}`));
+    }, timeoutMs);
+
+    promise
+      .then((result) => {
+        clearTimeout(timeoutId);
+        resolve(result);
+      })
+      .catch((error) => {
+        clearTimeout(timeoutId);
+        reject(error);
+      });
+  });
+}
+
 function indexObject(obj, is) {
   if (!is) throw new Error("undefined index");
   if (typeof is === "string") return indexObject(obj, is.split("."));
@@ -418,19 +443,35 @@ class RPC extends _utils_index_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
             let registeredCount = 0;
             const failedServices = [];
 
+            // Use timeout for service registration to prevent hanging
+            const serviceRegistrationTimeout = this._method_timeout || 30000;
+
             for (let service of services) {
               try {
                 const serviceInfo = this._extract_service_info(service);
-                await manager.registerService(serviceInfo);
+                await withTimeout(
+                  manager.registerService(serviceInfo),
+                  serviceRegistrationTimeout,
+                  `Timeout registering service ${service.id || "unknown"}`,
+                );
                 registeredCount++;
                 console.debug(
                   `Successfully registered service: ${service.id || "unknown"}`,
                 );
               } catch (serviceError) {
                 failedServices.push(service.id || "unknown");
-                console.error(
-                  `Failed to register service ${service.id || "unknown"}: ${serviceError}`,
-                );
+                if (
+                  serviceError.message &&
+                  serviceError.message.includes("TimeoutError")
+                ) {
+                  console.error(
+                    `Timeout registering service ${service.id || "unknown"}`,
+                  );
+                } else {
+                  console.error(
+                    `Failed to register service ${service.id || "unknown"}: ${serviceError}`,
+                  );
+                }
               }
             }
 
@@ -478,10 +519,12 @@ class RPC extends _utils_index_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
                   }
                 };
 
-                // Subscribe to the event topic first
-                this._clientDisconnectedSubscription = await manager.subscribe([
-                  "client_disconnected",
-                ]);
+                // Subscribe to the event topic first with timeout
+                this._clientDisconnectedSubscription = await withTimeout(
+                  manager.subscribe(["client_disconnected"]),
+                  serviceRegistrationTimeout,
+                  "Timeout subscribing to client_disconnected events",
+                );
 
                 // Then register the local event handler
                 this.on("client_disconnected", handleClientDisconnected);
@@ -1232,7 +1275,7 @@ class RPC extends _utils_index_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       config.workspace || this._local_workspace || this._connection.workspace;
     if (!config.workspace) {
       throw new Error(
-        "Workspace is not set. Please ensure the connection has a workspace or set local_workspace."
+        "Workspace is not set. Please ensure the connection has a workspace or set local_workspace.",
       );
     }
     const skipContext = config.require_context;
@@ -2654,7 +2697,11 @@ class RPC extends _utils_index_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
           local_workspace,
         ),
       };
-    } else if (aObject.constructor === Object || Array.isArray(aObject) || aObject instanceof RemoteService) {
+    } else if (
+      aObject.constructor === Object ||
+      Array.isArray(aObject) ||
+      aObject instanceof RemoteService
+    ) {
       bObject = isarray ? [] : {};
       const keys = Object.keys(aObject);
       for (let k of keys) {
@@ -6278,12 +6325,22 @@ class WebsocketRPCConnection {
             }
           } catch (e) {
             if (`${e}`.includes("ConnectionAbortedError:")) {
-              console.warn("Failed to reconnect, connection aborted:", e);
+              console.warn("Server refused to reconnect:", e);
+              // Mark as closed and notify the application
+              this._closed = true;
+              if (this._handle_disconnected) {
+                this._handle_disconnected(`Server refused reconnection: ${e}`);
+              }
               return;
             } else if (`${e}`.includes("NotImplementedError:")) {
               console.error(
                 `${e}\nIt appears that you are trying to connect to a hypha server that is older than 0.20.0, please upgrade the hypha server or use the websocket client in imjoy-rpc(https://www.npmjs.com/package/imjoy-rpc) instead`,
               );
+              // Mark as closed to prevent further reconnection attempts
+              this._closed = true;
+              if (this._handle_disconnected) {
+                this._handle_disconnected(`Server too old: ${e}`);
+              }
               return;
             }
 
@@ -6337,21 +6394,20 @@ class WebsocketRPCConnection {
                 await reconnect();
               } else {
                 console.error(
-                  `Failed to reconnect after ${MAX_RETRY} attempts, giving up. Exiting process.`,
+                  `Failed to reconnect after ${MAX_RETRY} attempts, giving up.`,
                 );
+                // Mark as closed to prevent further reconnection attempts
+                this._closed = true;
                 // Notify about max retry exceeded
                 if (this._handle_disconnected) {
                   this._handle_disconnected(
                     "Max reconnection attempts exceeded",
                   );
                 }
-                // Exit process to prevent stuck event loop
-                if (typeof process !== "undefined" && process.exit) {
-                  console.error(
-                    "Forcing process exit due to unrecoverable connection failure",
-                  );
-                  process.exit(1);
-                }
+                // Note: We intentionally do NOT call process.exit() here.
+                // Instead, we mark the connection as closed and let the
+                // application handle the failure through the disconnected
+                // handler or by checking connection state.
               }
             }, finalDelay);
             this._reconnect_timeouts.add(timeoutId);
@@ -6468,7 +6524,7 @@ async function logout(config) {
     if (!svc.logout) {
       throw new Error(
         "Logout is not supported by this server. " +
-        "Please upgrade the Hypha server to a version that supports logout."
+          "Please upgrade the Hypha server to a version that supports logout.",
       );
     }
 
@@ -6476,7 +6532,9 @@ async function logout(config) {
     if (callback) {
       await callback(context);
     } else {
-      console.log(`Please open your browser to logout at ${context.logout_url}`);
+      console.log(
+        `Please open your browser to logout at ${context.logout_url}`,
+      );
     }
     return context;
   } catch (error) {