hypha-rpc 0.20.85 → 0.20.86

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);
@@ -6278,12 +6321,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 +6390,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);