storyboard-bridge 0.9.2 → 0.9.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "storyboard-bridge",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "Desktop bridge that powers a hosted Storyboard AI webapp with your own local Claude Code / Gemini CLI login (no API key).",
   "type": "module",
   "bin": {

package/tryinfer_client.py

@@ -123,6 +123,20 @@ def _fetch_expr(method, url, body):
     return "".join(parts)
 
 
+# JS run inside the tab to force Clerk to re-mint its short-lived session token (which updates the __session
+# cookie tryinfer's API reads). Works on a HIDDEN/backgrounded tab — Runtime.evaluate ignores visibility — so
+# we never foreground. Returns {ok:true} on success, {ok:false,reason|error} if Clerk isn't loaded yet.
+_CLERK_REFRESH_EXPR = (
+    "(async()=>{try{"
+    "const c=window.Clerk;"
+    "if(c&&c.session&&typeof c.session.getToken==='function'){"
+    "await c.session.getToken({skipCache:true});"
+    "return JSON.stringify({ok:true});}"
+    "return JSON.stringify({ok:false,reason:'clerk-not-ready'});"
+    "}catch(e){return JSON.stringify({ok:false,error:String((e&&e.message)||e)});}})()"
+)
+
+
 # CDP errors that mean the execution context we ran fetch() in is gone — the Studio tab NAVIGATED (it changes
 # route when a generation starts/finishes) or reloaded. We recover by re-attaching to the tab's fresh context.
 _CTX_DEAD = ("navigated", "context", "closed", "-32000", "detached", "Session with given id")
@@ -189,21 +203,30 @@ class BrowserSession:
         if not tid:
             raise RuntimeError(f"No open tab whose URL contains '{self.match}'. Open tryinfer.com and log in.")
         # A HOST tab left in the background CAN get discarded/frozen/throttled by Chrome (no live renderer),
-        # in which case attaching works but Runtime.enable hangs waiting for a renderer → CDP timeout.
-        # We DON'T foreground on the happy path (activateTarget steals focus, which is annoying in a browser
-        # the user is actively using). Instead attempt 0 attaches WITHOUT foregrounding, with a short
-        # Runtime.enable timeout so a genuinely stalled tab fails fast; only THEN do later attempts fall back
-        # to activateTarget (foreground/wake) to spin the renderer back up.
+        # in which case attaching works but Runtime.enable hangs waiting for a renderer → CDP timeout. We wake
+        # it WITHOUT foregrounding (activateTarget steals focus, which is annoying in a browser the user is
+        # actively using), escalating only as far as needed:
+        #   attempt 0 — plain attach, short Runtime.enable timeout so a stalled tab fails fast.
+        #   attempt 1 — focus-free un-freeze: Page.setWebLifecycleState('active') resumes a frozen renderer
+        #               without bringing the tab forward.
+        #   attempt 2 — LAST RESORT ONLY: Target.activateTarget (this is the sole path that steals focus, and
+        #               only after a plain attach AND a focus-free un-freeze both failed — a fully discarded tab).
         last = None
         for attempt in range(3):
             self.cdp = CDP(self.browser_ws)
             try:
-                if attempt > 0:
-                    try: self.cdp.call("Target.activateTarget", {"targetId": tid}, timeout=10)  # wake a stalled tab
+                if attempt == 2:
+                    try: self.cdp.call("Target.activateTarget", {"targetId": tid}, timeout=10)  # foreground: last resort
                     except Exception: pass
                 self.session_id = self.cdp.call("Target.attachToTarget", {"targetId": tid, "flatten": True}, timeout=15)["sessionId"]
-                # short timeout on the no-focus first pass → fail fast into the activate() fallback if the
-                # renderer is asleep; full timeout once we've foregrounded it.
+                if attempt == 1:
+                    # attempt 0 stalled → renderer frozen. Resume it without foregrounding.
+                    try:
+                        self.cdp.call("Page.enable", session_id=self.session_id, timeout=8)
+                        self.cdp.call("Page.setWebLifecycleState", {"state": "active"}, session_id=self.session_id, timeout=8)
+                    except Exception as e:
+                        log(f"   focus-free un-freeze failed ({e})")
+                # short timeout on the first pass → fail fast into the wake escalation if the renderer is asleep.
                 self.cdp.call("Runtime.enable", session_id=self.session_id, timeout=(6 if attempt == 0 else 20))
                 log(f"Routing API calls through tab: {url}")
                 return
@@ -212,12 +235,13 @@ class BrowserSession:
                 try: self.cdp.close()
                 except Exception: pass
                 if attempt < 2:
-                    log(f"   CDP attach stalled (waking tab in foreground) — retrying… ({e})")
+                    log(f"   CDP attach stalled — {'un-freezing (no focus)' if attempt == 0 else 'foregrounding (last resort)'}… ({e})")
                     time.sleep(2)
         raise RuntimeError(f"couldn't attach to the tryinfer tab — is it awake + logged in? ({last})")
 
     def request(self, method, url, body=None, timeout=120, retries=4):
         last = None
+        refreshed = False  # one focus-free session re-mint per request (a genuine logout still surfaces as 401)
         for attempt in range(retries):
             try:
                 res = self.cdp.call(
@@ -226,12 +250,16 @@ class BrowserSession:
                     session_id=self.session_id, timeout=timeout)
             except Exception as e:
                 last = f"CDP evaluate error: {e}"
-                # tab navigated / context died → re-attach to the new context and retry (don't lose the poll).
-                if any(s in str(e) for s in _CTX_DEAD):
-                    log(f"   tab navigated — re-attaching… ({e})")
-                    time.sleep(1)
-                    try: self._attach()
-                    except Exception as e2: last = f"re-attach failed: {e2}"
+                # The tab stopped answering CDP. Two shapes, ONE recovery: the context died (tab navigated /
+                # closed — _CTX_DEAD) OR the renderer froze/was discarded and the evaluate TIMED OUT waiting
+                # for a response. Previously we only re-attached on _CTX_DEAD, so a mid-request freeze just
+                # hammered the same dead session until it failed. Now we re-attach on ANY evaluate error —
+                # _attach focus-free un-freezes a stalled renderer (setWebLifecycleState) — and it also swaps
+                # in a fresh CDP socket, clearing any response desynced by the timeout.
+                log(f"   tab unresponsive — re-attaching (no focus)… ({e})")
+                time.sleep(1)
+                try: self._attach()
+                except Exception as e2: last = f"re-attach failed: {e2}"
                 if attempt < retries - 1:
                     time.sleep(2); continue
                 raise RuntimeError(last)
@@ -240,15 +268,67 @@ class BrowserSession:
                 last = f"evaluate failed: {res.get('exceptionDetails')}"
             else:
                 data = json.loads(val)
-                if data.get("status") == 0:
+                status = data.get("status")
+                if status == 0:
                     last = f"in-page fetch error: {data.get('error')}"
+                elif status in (401, 403) and not refreshed:
+                    # Stale Clerk session: a backgrounded tab stops refreshing __session, so tryinfer 401s.
+                    # Re-mint the cookie WITHOUT foregrounding, then retry immediately with the fresh session.
+                    refreshed = True
+                    last = f"auth {status} — re-minting session (no focus)"
+                    log(f"   {last}…")
+                    try: self.refresh_session(hard=True)
+                    except Exception as e2: last = f"session refresh failed: {e2}"
+                    continue  # skip the backoff sleep — retry now that the cookie is fresh
                 else:
-                    return PageResponse(data["status"], data["body"])
+                    return PageResponse(status, data["body"])
             if attempt < retries - 1:
                 log(f"   transient request error, retrying… ({last})")
                 time.sleep(3)
         raise RuntimeError(last)
 
+    def _clerk_mint(self):
+        """Force Clerk to mint a fresh session token (updates __session) via evaluated JS. No foreground.
+        Returns True if a token was minted, False if Clerk isn't loaded / errored."""
+        try:
+            res = self.cdp.call(
+                "Runtime.evaluate",
+                {"expression": _CLERK_REFRESH_EXPR, "awaitPromise": True, "returnByValue": True},
+                session_id=self.session_id, timeout=20)
+            val = res.get("result", {}).get("value")
+            data = json.loads(val) if val else {}
+            if data.get("ok"):
+                log("   session re-minted via Clerk (no focus)")
+                return True
+            log(f"   Clerk refresh unavailable: {data.get('reason') or data.get('error')}")
+        except Exception as e:
+            log(f"   Clerk refresh errored: {e}")
+        return False
+
+    def refresh_session(self, hard=False):
+        """Re-mint the Clerk session cookie WITHOUT foregrounding the tab. A backgrounded tab stops running
+        Clerk's periodic token refresh, so __session goes stale and tryinfer 401s. Focus-free recovery:
+          1. Page.setWebLifecycleState('active') — resume a throttled/frozen renderer (does NOT foreground).
+          2. window.Clerk.session.getToken({skipCache:true}) — force a fresh token → fresh cookie.
+          3. (hard only) if Clerk isn't reachable, Page.reload + re-attach so Clerk re-inits from scratch.
+        Returns True if a fresh token was minted."""
+        try:
+            self.cdp.call("Page.enable", session_id=self.session_id, timeout=8)
+            self.cdp.call("Page.setWebLifecycleState", {"state": "active"}, session_id=self.session_id, timeout=8)
+        except Exception:
+            pass
+        if self._clerk_mint():
+            return True
+        if hard:
+            log("   Clerk not ready — reloading tab to re-init the session (no focus)…")
+            try: self.cdp.call("Page.reload", session_id=self.session_id, timeout=15)
+            except Exception as e: log(f"   reload failed: {e}")
+            time.sleep(5)
+            try: self._attach()
+            except Exception as e: log(f"   re-attach after reload failed: {e}")
+            return self._clerk_mint()
+        return False
+
     def close(self):
         try:
             self.cdp.call("Target.detachFromTarget", {"sessionId": self.session_id}, timeout=5)