hypha-rpc 0.21.44 → 0.21.47

package/coverage/html/index.html

@@ -86,7 +86,7 @@
             <div class='footer quiet pad2 space-top1 center small'>
                 Code coverage generated by
                 <a href="https://istanbul.js.org/" target="_blank" rel="noopener noreferrer">istanbul</a>
-                at 2026-07-06T10:50:07.482Z
+                at 2026-08-31T13:24:20.113Z
             </div>
         <script src="prettify.js"></script>
         <script>

package/dist/hypha-rpc-websocket.js

@@ -10389,6 +10389,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   getRemoteService: () => (/* binding */ getRemoteService),
 /* harmony export */   getRemoteServiceHTTP: () => (/* reexport safe */ _http_client_js__WEBPACK_IMPORTED_MODULE_5__.getRemoteServiceHTTP),
 /* harmony export */   hyphaWebsocketClient: () => (/* binding */ hyphaWebsocketClient),
+/* harmony export */   isLoginCompleteMessage: () => (/* binding */ isLoginCompleteMessage),
 /* harmony export */   loadRequirements: () => (/* reexport safe */ _utils_index_js__WEBPACK_IMPORTED_MODULE_2__.loadRequirements),
 /* harmony export */   login: () => (/* binding */ login),
 /* harmony export */   logout: () => (/* binding */ logout),
@@ -10424,6 +10425,16 @@ __webpack_require__.r(__webpack_exports__);
 
 const MAX_RETRY = 1000000;
 
+// Reconnect flap control: a connection that stays up for less than
+// RECONNECT_FLAP_WINDOW_MS after connecting is treated as a "flap" (e.g. the
+// server accepts the reconnect then immediately supersedes/closes it because a
+// prior session with the same client_id is still active). Flaps escalate the
+// backoff across reconnect cycles — instead of resetting to an immediate retry
+// each time — and never reconnect faster than RECONNECT_MIN_DELAY_MS while
+// flapping. This prevents a tight succeed→superseded→succeed reconnect storm.
+const RECONNECT_FLAP_WINDOW_MS = 5000;
+const RECONNECT_MIN_DELAY_MS = 1000;
+
 // When the socket errors/closes during the handshake, wait briefly before
 // rejecting with the generic reason: the server usually sends a descriptive
 // {type:"error"} message (e.g. token/workspace mismatch) just before closing,
@@ -10481,6 +10492,8 @@ class WebsocketRPCConnection {
     this._reconnecting = false; // Mutex to prevent overlapping reconnection attempts
     this._closedDuringReconnect = false; // Flag for close events during reconnection
     this._disconnectedNotified = false;
+    this._lastConnectedTime = 0; // ms timestamp of last successful connection_info
+    this._reconnectFlapCount = 0; // consecutive short-lived (flapping) connections
   }
 
   /**
@@ -10633,6 +10646,9 @@ class WebsocketRPCConnection {
         const first_message = JSON.parse(data);
         if (first_message.type == "connection_info") {
           settled = true;
+          // Mark when a connection is fully established; used for flap
+          // detection when the connection later closes.
+          this._lastConnectedTime = Date.now();
           this.connection_info = first_message;
           if (this._workspace) {
             (0,_utils_index_js__WEBPACK_IMPORTED_MODULE_2__.assert)(
@@ -10840,7 +10856,25 @@ class WebsocketRPCConnection {
         }
         this._reconnecting = true;
 
-        let retry = 0;
+        // Flap detection: if the connection that just closed was short-lived,
+        // escalate the backoff across reconnect cycles instead of resetting to
+        // an immediate retry. A healthy long-lived connection resets the count
+        // so genuine disconnects still recover fast.
+        const aliveMs = this._lastConnectedTime
+          ? Date.now() - this._lastConnectedTime
+          : Infinity;
+        if (aliveMs < RECONNECT_FLAP_WINDOW_MS) {
+          this._reconnectFlapCount += 1;
+        } else {
+          this._reconnectFlapCount = 0;
+        }
+
+        // Seed the retry counter from the flap history so a REPEATED flap
+        // escalates the backoff. The first flap is free (retry 0 → immediate)
+        // so a genuine single quick disconnect still recovers fast; only the
+        // 2nd+ consecutive short-lived connection is delayed, which is the
+        // succeed→superseded storm signature.
+        let retry = Math.max(0, this._reconnectFlapCount - 1);
         const baseDelay = 1000; // Start with 1 second
         const maxDelay = 60000; // Maximum delay of 60 seconds
         const maxJitter = 0.1; // Maximum jitter factor
@@ -10980,7 +11014,35 @@ class WebsocketRPCConnection {
             this._reconnect_timeouts.add(timeoutId);
           }
         };
-        reconnect();
+
+        // Kick off the reconnect loop. When flapping (retry seeded > 0), delay
+        // the first attempt with the same exponential backoff + jitter and a
+        // minimum floor, so a succeed→superseded loop cannot hammer the server.
+        // A genuine disconnect after a healthy connection (retry === 0) still
+        // reconnects immediately.
+        if (retry > 0) {
+          const delay = Math.min(baseDelay * Math.pow(2, retry - 1), maxDelay);
+          const jitter = (Math.random() * 2 - 1) * maxJitter * delay;
+          const finalDelay = Math.max(RECONNECT_MIN_DELAY_MS, delay + jitter);
+          const timeoutId = setTimeout(() => {
+            this._reconnect_timeouts.delete(timeoutId);
+            if (this._closed) {
+              this._reconnecting = false;
+              return;
+            }
+            if (
+              this._websocket &&
+              this._websocket.readyState === WebSocket.OPEN
+            ) {
+              this._reconnecting = false;
+              return;
+            }
+            reconnect();
+          }, finalDelay);
+          this._reconnect_timeouts.add(timeoutId);
+        } else {
+          reconnect();
+        }
       }
     } else {
       // Clean up timers in all cases
@@ -11034,6 +11096,89 @@ function normalizeServerUrl(server_url) {
   return server_url;
 }
 
+/**
+ * Validate a window "message" event as a hypha login-complete signal.
+ *
+ * Exported so it can be unit-tested without a browser. The completion message
+ * carries ONLY the public session key (never a token); a valid message merely
+ * decides when to tear down the inline login modal — the token itself is always
+ * fetched over the trusted check() RPC, so a forged message cannot inject one.
+ */
+function isLoginCompleteMessage(event, expectedOrigin, expectedKey) {
+  if (!event || event.origin !== expectedOrigin) return false;
+  const data = event.data;
+  if (!data || typeof data !== "object") return false;
+  return data.type === "hypha-login-complete" && data.key === expectedKey;
+}
+
+/**
+ * Render the login page in an in-page modal iframe (browser only). This is the
+ * no-popup alternative to opening login_url in a popup window. Returns
+ * { teardown } to remove the modal; the close button invokes onCancel.
+ */
+function openLoginModal(loginUrl, { container, onCancel } = {}) {
+  const doc = window.document;
+  const overlay = doc.createElement("div");
+  overlay.setAttribute("data-hypha-login-modal", "");
+  if (!container) {
+    Object.assign(overlay.style, {
+      position: "fixed",
+      inset: "0",
+      zIndex: "2147483647",
+      background: "rgba(0,0,0,0.5)",
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "center",
+    });
+  }
+  const frame = doc.createElement("div");
+  Object.assign(frame.style, {
+    position: "relative",
+    width: "min(480px, 92vw)",
+    height: "min(640px, 90vh)",
+    background: "#fff",
+    borderRadius: "10px",
+    overflow: "hidden",
+    boxShadow: "0 10px 40px rgba(0,0,0,0.3)",
+  });
+  const closeBtn = doc.createElement("button");
+  closeBtn.setAttribute("aria-label", "Close login");
+  closeBtn.textContent = "×";
+  Object.assign(closeBtn.style, {
+    position: "absolute",
+    top: "6px",
+    right: "10px",
+    zIndex: "1",
+    border: "none",
+    background: "transparent",
+    fontSize: "24px",
+    lineHeight: "1",
+    cursor: "pointer",
+    color: "#555",
+  });
+  const iframe = doc.createElement("iframe");
+  iframe.src = loginUrl;
+  iframe.setAttribute("title", "Hypha login");
+  Object.assign(iframe.style, { width: "100%", height: "100%", border: "none" });
+
+  frame.appendChild(closeBtn);
+  frame.appendChild(iframe);
+  overlay.appendChild(frame);
+  (container || doc.body).appendChild(overlay);
+
+  let torn = false;
+  const teardown = () => {
+    if (torn) return;
+    torn = true;
+    if (overlay.parentNode) overlay.parentNode.removeChild(overlay);
+  };
+  closeBtn.addEventListener("click", () => {
+    teardown();
+    if (onCancel) onCancel();
+  });
+  return { teardown };
+}
+
 /**
  * Login to the hypha server.
  *
@@ -11044,6 +11189,13 @@ function normalizeServerUrl(server_url) {
  *   expires_in: Token expiration time (optional)
  *   login_timeout: Timeout for login process (default: 60)
  *   login_callback: Callback function for login URL (optional)
+ *   mode: "popup" (default) or "inline". In "inline" mode (browser only, and only
+ *         when no login_callback is given) the login page is rendered in an in-page
+ *         modal iframe instead of a popup window — for host apps that block popups.
+ *         Works with local-auth and custom-auth providers whose login page is
+ *         iframe-embeddable; does NOT apply to Auth0 (keep the popup for it).
+ *   container: optional DOM element to mount the inline login modal into
+ *              (default: a full-screen overlay on document.body)
  *   profile: Whether to return user profile (optional)
  *   additional_headers: Additional HTTP headers (optional)
  *   transport: Transport type - "websocket" (default) or "http"
@@ -11058,6 +11210,7 @@ async function login(config) {
   const profile = config.profile;
   const additional_headers = config.additional_headers;
   const transport = config.transport || "websocket";
+  const mode = config.mode || "popup";
 
   const server = await connectToServer({
     name: "initial login client",
@@ -11074,8 +11227,58 @@ async function login(config) {
     } else {
       context = await svc.start();
     }
+    const canInline =
+      mode === "inline" &&
+      !callback &&
+      typeof window !== "undefined" &&
+      window.document;
+
     if (callback) {
+      if (mode === "inline") {
+        _logger.warn(
+          "login: both login_callback and mode:'inline' were given; using login_callback.",
+        );
+      }
       await callback(context);
+    } else if (canInline) {
+      // No-popup mode: render the login page in an in-page modal iframe and wait
+      // for its 'hypha-login-complete' postMessage. The token is NOT taken from
+      // the message — it is always fetched over the trusted check() RPC (which is
+      // also the real timeout authority and covers a dropped/early message).
+      const origin = new URL(config.server_url).origin;
+      const loginUrl = new URL(context.login_url, config.server_url).href;
+      return await new Promise((resolve, reject) => {
+        let modal = null;
+        let msgListener = null;
+        let done = false;
+        const cleanup = () => {
+          if (msgListener) window.removeEventListener("message", msgListener);
+          if (modal) modal.teardown();
+        };
+        const finish = (fn, arg) => {
+          if (done) return;
+          done = true;
+          cleanup();
+          fn(arg);
+        };
+        const fetchToken = () =>
+          svc
+            .check(context.key, { timeout, profile, _rkwargs: true })
+            .then((r) => finish(resolve, r))
+            .catch((e) => finish(reject, e));
+        msgListener = (event) => {
+          if (!isLoginCompleteMessage(event, origin, context.key)) return;
+          fetchToken();
+        };
+        window.addEventListener("message", msgListener);
+        modal = openLoginModal(loginUrl, {
+          container: config.container,
+          onCancel: () => finish(reject, new Error("Login cancelled by user")),
+        });
+        // Safety net: resolves when the user completes login even if the
+        // postMessage is missed, and enforces the login timeout server-side.
+        fetchToken();
+      });
     } else {
       _logger.log(`Please open your browser and login at ${context.login_url}`);
     }
@@ -11744,6 +11947,7 @@ const hyphaWebsocketClient = {
   schemaFunction: _utils_schema_js__WEBPACK_IMPORTED_MODULE_3__.schemaFunction,
   loadRequirements: _utils_index_js__WEBPACK_IMPORTED_MODULE_2__.loadRequirements,
   login,
+  isLoginCompleteMessage,
   logout,
   connectToServer,
   connectToServerHTTP: _http_client_js__WEBPACK_IMPORTED_MODULE_5__.connectToServerHTTP,