storyboard-bridge 0.7.3 → 0.9.0

package/index.mjs

@@ -319,6 +319,9 @@ function handleTryinfer(msg, ws) {
   const p = msg.params || {};
   try {
     const args = ['-u', TF_SCRIPT, '--emit-json'];
+    // Pin this render to the worker the backend leased. Applies to RESUMES too: a tryinfer task is only
+    // visible to the session that created it, so polling it from another context returns nothing.
+    if (p.contextId) args.push('--context', String(p.contextId));
     if (p.resumeTaskId) {
       args.push('--resume-task', String(p.resumeTaskId)); // poll an existing task, no submit
     } else {
@@ -327,6 +330,9 @@ function handleTryinfer(msg, ws) {
         '--duration', String(Math.max(1, Math.round(p.durationSec || 5))),
         '--aspect', String(p.aspectRatio || '1:1'),
         '--resolution', String(p.resolution || '1080p'));
+      // tryinfer-side model name ('seedance-2.5', 'seedance-2.0-pro', 'seedream-5.0-pro'). Older backends
+      // don't send it — then the client keeps its capability-aware default, so both directions stay compatible.
+      if (p.model) args.push('--model', String(p.model));
       if (p.audio === false) args.push('--no-audio');
       if (p.numImages && p.numImages > 1) args.push('--num', String(p.numImages)); // Seedream image batch (2x)
       for (const u of (Array.isArray(p.imageUrls) ? p.imageUrls : [])) args.push('--image-url', String(u));
@@ -477,7 +483,7 @@ function connect() {
       gemini: await cliAvailable(BIN_FOR.gemini),
     };
     const hfCli = await cliAvailable(HF_CLI); // official `higgsfield` CLI present + runnable → can serve credit-billed renders
-    ws.send(JSON.stringify({ type: 'hello', version: VERSION, provider: PROVIDER, providers, files: !!FILES_ROOT, higgsfield: HIGGSFIELD, higgsfieldCli: hfCli, infer: INFER, inflight: [...inflightJobs] }));
+    ws.send(JSON.stringify({ type: 'hello', version: VERSION, provider: PROVIDER, providers, files: !!FILES_ROOT, higgsfield: HIGGSFIELD, higgsfieldCli: hfCli, infer: INFER, tfWorkers: true, inflight: [...inflightJobs] }));
     log(`connected to ${url} — serving jobs with: ${PROVIDER} (${BIN})${FILES_ROOT ? `; files → ${FILES_ROOT}` : ''}${HIGGSFIELD ? `; HIGGSFIELD HOST (python: ${PYTHON_BIN}, cdp: ${CDP_HTTP})` : ''}${hfCli ? `; HIGGSFIELD CLI (${HF_CLI})` : ''}`);
     if (!providers[PROVIDER]) {
       log(`WARNING: '${BIN}' was not found / not runnable. Install it and log in, or pass --provider/--*_BIN. Jobs will fail until then.`);
@@ -543,6 +549,22 @@ function connect() {
     } else if (msg.type === 'tryinfer' && msg.id) {
       if (!INFER) ws.send(JSON.stringify({ type: 'tryinferEvent', id: msg.id, event: 'error', reason: 'disabled', detail: 'this bridge was not started with --infer' }));
       else { log(`tryinfer ${msg.id} → running`); handleTryinfer(msg, ws); }
+    } else if (msg.type === 'tryinfer-workers' && msg.id) {
+      // Pool discovery: report every open tryinfer tab with its browserContextId. Cheap + read-only, so
+      // the backend can call it before each lease and track a pool whose membership keeps changing.
+      if (!INFER) ws.send(JSON.stringify({ type: 'tryinferWorkers', id: msg.id, workers: [], error: 'this bridge was not started with --infer' }));
+      else {
+        const child = spawn(PYTHON_BIN, ['-u', TF_SCRIPT, '--list-workers'], { env: { ...process.env, CDP_HTTP }, stdio: ['ignore', 'pipe', 'pipe'] });
+        let out = '', err = '';
+        child.stdout.on('data', (d) => { out += d.toString(); });
+        child.stderr.on('data', (d) => { err = (err + d.toString()).slice(-2000); });
+        child.on('error', (e) => ws.send(JSON.stringify({ type: 'tryinferWorkers', id: msg.id, workers: [], error: `${PYTHON_BIN}: ${e.message}` })));
+        child.on('close', () => {
+          let parsed = null;
+          try { parsed = JSON.parse(out.trim().split('\n').filter(Boolean).pop() || 'null'); } catch { /* fall through */ }
+          ws.send(JSON.stringify({ type: 'tryinferWorkers', id: msg.id, workers: parsed?.workers ?? [], ...(parsed ? {} : { error: err || 'no worker list from the client' }) }));
+        });
+      }
     } else if (msg.type === 'tryinfer-cancel' && msg.id) {
       const child = tfChildren.get(msg.id);
       if (child) { log(`tryinfer ${msg.id} → cancel`); try { child.kill('SIGTERM'); } catch { /* already gone */ } tfChildren.delete(msg.id); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "storyboard-bridge",
-  "version": "0.7.3",
+  "version": "0.9.0",
   "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

@@ -128,33 +128,88 @@ def _fetch_expr(method, url, body):
 _CTX_DEAD = ("navigated", "context", "closed", "-32000", "detached", "Session with given id")
 
 
+# ---- worker discovery ----
+# Every logged-in tryinfer tab is an interchangeable WORKER. A worker is identified by its
+# browserContextId — the isolated session (own cookies), which is what a separate Chrome profile or a temp
+# context actually is. We deliberately do NOT identify workers by account/email: the pool is anonymous and
+# its membership changes as profiles/contexts come and go.
+#
+# NOTE the gotcha this exists to avoid: /json/list is the easy endpoint but does NOT carry
+# browserContextId, so it cannot tell two tryinfer tabs apart. Target.getTargets does.
+def list_workers(cdp_http, match="tryinfer"):
+    """[{contextId, targetId, url, title}] — one entry per open tryinfer tab, newest Chrome state."""
+    ver = http_json(f"{cdp_http}/json/version")
+    cdp = CDP(ver["webSocketDebuggerUrl"])
+    try:
+        infos = cdp.call("Target.getTargets", timeout=15).get("targetInfos", [])
+    finally:
+        cdp.close()
+    out = []
+    for t in infos:
+        if t.get("type") == "page" and match in (t.get("url") or ""):
+            out.append({"contextId": t.get("browserContextId"), "targetId": t.get("targetId"),
+                        "url": t.get("url"), "title": t.get("title")})
+    return out
+
+
 class BrowserSession:
-    def __init__(self, cdp_http, match):
+    def __init__(self, cdp_http, match, context=None):
         self.cdp_http = cdp_http
         self.match = match
+        # when set, attach ONLY to a tab inside this browser context — that's how the backend pins a job to
+        # the worker it leased. Without it we keep the legacy first-match-by-URL behaviour (single worker).
+        self.context = context
         ver = http_json(f"{cdp_http}/json/version")
         log(f"Connected to {ver.get('Browser')}")
         self.browser_ws = ver["webSocketDebuggerUrl"]
         self.cdp = None
         self._attach()
 
+    def _resolve_tab(self):
+        """(targetId, url) of the tab to drive. Context-pinned when --context was given, else first URL match."""
+        if self.context:
+            for w in list_workers(self.cdp_http, self.match):
+                if w["contextId"] == self.context:
+                    return w["targetId"], w["url"]
+            # the context is gone (a temp context dies with Chrome, a profile window can be closed) — say so
+            # precisely, so the backend can drop that worker from the pool instead of guessing.
+            raise RuntimeError(f"WORKER_GONE: no tryinfer tab in browser context {self.context}")
+        for t in http_json(f"{self.cdp_http}/json/list"):
+            if t.get("type") == "page" and self.match in (t.get("url") or ""):
+                return t["id"], t["url"]
+        return None, None
+
     def _attach(self):
         """(Re)resolve the matching tab and attach a fresh Runtime session. Safe to call repeatedly — used
         both at startup and to recover after the Studio tab navigates mid-poll (which kills the context)."""
         if self.cdp:
             try: self.cdp.close()
             except Exception: pass
-        tid = url = None
-        for t in http_json(f"{self.cdp_http}/json/list"):
-            if t.get("type") == "page" and self.match in (t.get("url") or ""):
-                tid, url = t["id"], t["url"]
-                break
+        tid, url = self._resolve_tab()
         if not tid:
             raise RuntimeError(f"No open tab whose URL contains '{self.match}'. Open tryinfer.com and log in.")
-        self.cdp = CDP(self.browser_ws)
-        self.session_id = self.cdp.call("Target.attachToTarget", {"targetId": tid, "flatten": True})["sessionId"]
-        self.cdp.call("Runtime.enable", session_id=self.session_id)
-        log(f"Routing API calls through tab: {url}")
+        # A HOST tab left in the background gets DISCARDED/frozen by Chrome (no live renderer). Attaching still
+        # works, but Runtime.enable then hangs waiting for a renderer → "Timed out waiting for CDP response".
+        # Activate (foreground/wake) the tab first, and retry attach+enable a couple times so a just-woken tab
+        # gets a moment to spin its renderer back up.
+        last = None
+        for attempt in range(3):
+            self.cdp = CDP(self.browser_ws)
+            try:
+                try: self.cdp.call("Target.activateTarget", {"targetId": tid}, timeout=10)  # wake a discarded tab
+                except Exception: pass
+                self.session_id = self.cdp.call("Target.attachToTarget", {"targetId": tid, "flatten": True}, timeout=15)["sessionId"]
+                self.cdp.call("Runtime.enable", session_id=self.session_id, timeout=20)
+                log(f"Routing API calls through tab: {url}")
+                return
+            except Exception as e:
+                last = e
+                try: self.cdp.close()
+                except Exception: pass
+                if attempt < 2:
+                    log(f"   CDP attach stalled (tab may be waking) — retrying… ({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
@@ -302,10 +357,22 @@ def main():
     ap.add_argument("--resume-task", default=None, help="skip submit; just poll+result an existing task id")
     ap.add_argument("--emit-json", action="store_true", help="NDJSON events on stdout, human logs on stderr")
     ap.add_argument("--match", default="tryinfer", help="substring of the logged-in tab's URL")
+    ap.add_argument("--context", default=None,
+                    help="pin to the tryinfer tab in this browserContextId (a pool worker). Omit = first URL match.")
+    ap.add_argument("--list-workers", action="store_true",
+                    help="print [{contextId,targetId,url,title}] for every open tryinfer tab and exit (discovery)")
     ap.add_argument("--host", default="localhost")
     ap.add_argument("--port", type=int, default=9222)
     args = ap.parse_args()
 
+    # discovery mode: no render, no tab attach — just report the pool as Chrome currently sees it.
+    if args.list_workers:
+        try:
+            print(json.dumps({"workers": list_workers(f"http://{args.host}:{args.port}", args.match)}))
+        except Exception as e:
+            print(json.dumps({"workers": [], "error": str(e)}))
+        return
+
     if args.emit_json:
         global _JSON_OUT
         _JSON_OUT = sys.stdout
@@ -318,7 +385,7 @@ def main():
     try:
         # inside the try so a connect/tab failure ("No open tab … Open tryinfer.com and log in") surfaces as a
         # clean error EVENT the node can show — not a raw Python traceback dumped to the UI.
-        sess = BrowserSession(f"http://{args.host}:{args.port}", args.match)
+        sess = BrowserSession(f"http://{args.host}:{args.port}", args.match, context=args.context)
         if args.resume_task:
             task_id = args.resume_task
             log(f"resuming task {task_id}")