storyboard-bridge 0.7.1 → 0.7.2

package/index.mjs

@@ -328,6 +328,7 @@ function handleTryinfer(msg, ws) {
         '--aspect', String(p.aspectRatio || '1:1'),
         '--resolution', String(p.resolution || '1080p'));
       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));
       if (p.lastFrameUrl) args.push('--last-frame-url', String(p.lastFrameUrl)); // image-to-video END frame
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "storyboard-bridge",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "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,29 +123,58 @@ def _fetch_expr(method, url, body):
     return "".join(parts)
 
 
+# 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")
+
+
 class BrowserSession:
     def __init__(self, cdp_http, match):
+        self.cdp_http = cdp_http
+        self.match = match
         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 _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"{cdp_http}/json/list"):
-            if t.get("type") == "page" and match in (t.get("url") or ""):
+        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
         if not tid:
-            raise RuntimeError(f"No open tab whose URL contains '{match}'. Open tryinfer.com and log in.")
-        log(f"Routing API calls through tab: {url}")
-        self.cdp = CDP(ver["webSocketDebuggerUrl"])
+            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}")
 
-    def request(self, method, url, body=None, timeout=120, retries=3):
+    def request(self, method, url, body=None, timeout=120, retries=4):
         last = None
         for attempt in range(retries):
-            res = self.cdp.call(
-                "Runtime.evaluate",
-                {"expression": _fetch_expr(method, url, body), "awaitPromise": True, "returnByValue": True},
-                session_id=self.session_id, timeout=timeout)
+            try:
+                res = self.cdp.call(
+                    "Runtime.evaluate",
+                    {"expression": _fetch_expr(method, url, body), "awaitPromise": True, "returnByValue": True},
+                    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}"
+                if attempt < retries - 1:
+                    time.sleep(2); continue
+                raise RuntimeError(last)
             val = res.get("result", {}).get("value")
             if val is None:
                 last = f"evaluate failed: {res.get('exceptionDetails')}"
@@ -175,12 +204,19 @@ FAILED = {"FAILED", "ERROR", "CANCELLED", "CANCELED"}
 
 
 def submit(session, prompt, image_urls, duration, aspect, resolution, audio,
-           capability="reference-to-video", model="seedance-2.0-pro", last_frame_url=None):
-    """POST the generation task. Two shapes, both seedance-2.0-pro, both URL-based (no upload):
-      • reference-to-video: input.reference_image_urls[] + resolution
-      • image-to-video    : input.image_url (start) [+ last_frame_image_url (end)]  (no resolution)
-    Returns the task id."""
-    if capability == "image-to-video":
+           capability="reference-to-video", model="seedance-2.0-pro", last_frame_url=None,
+           num_images=1, input_json=None):
+    """POST a generation task. Video + image shapes, all URL-based (no upload). Returns the task id.
+      • reference-to-video : reference_image_urls[] + resolution + audio
+      • image-to-video     : image_url (start) [+ last_frame_image_url] + audio      (no resolution)
+      • edit (Seedream)    : image_url + prompt + num_images                         (UI hides aspect)
+      • text-to-image      : prompt + num_images + aspect_ratio                       (no image)
+    `input_json` overrides the WHOLE input dict verbatim — for probing undocumented combos."""
+    medium = "image" if capability in ("edit", "text-to-image") else "video"
+    if input_json is not None:
+        inp = json.loads(input_json)  # PROBE: send exactly this
+        meta = {"prompt": prompt, "medium": medium}
+    elif capability == "image-to-video":
         if not image_urls:
             raise RuntimeError("image-to-video needs a start frame (--image-url)")
         inp = {"image_url": image_urls[0], "prompt": prompt, "duration_seconds": duration, "aspect_ratio": aspect, "audio": audio}
@@ -189,6 +225,14 @@ def submit(session, prompt, image_urls, duration, aspect, resolution, audio,
         meta = {"prompt": prompt, "medium": "video", "ratio": RATIO_WORD.get(aspect, "square"), "kind": "animate", "sourceUrl": image_urls[0]}
         if last_frame_url:
             meta["lastFrameUrl"] = last_frame_url
+    elif capability == "edit":
+        if not image_urls:
+            raise RuntimeError("edit needs a source image (--image-url)")
+        inp = {"image_url": image_urls[0], "prompt": prompt, "num_images": num_images}
+        meta = {"prompt": prompt, "medium": "image", "kind": "edit", "sourceUrl": image_urls[0]}
+    elif capability == "text-to-image":
+        inp = {"prompt": prompt, "num_images": num_images, "aspect_ratio": aspect}
+        meta = {"prompt": prompt, "medium": "image", "kind": "generate"}
     else:  # reference-to-video
         inp = {"reference_image_urls": image_urls, "prompt": prompt, "duration_seconds": duration, "aspect_ratio": aspect, "resolution": resolution, "audio": audio}
         meta = {"prompt": prompt, "medium": "video", "ratio": RATIO_WORD.get(aspect, "square"), "kind": "reference", "referenceImageUrls": image_urls, "referenceRequestIds": []}
@@ -224,26 +268,33 @@ def poll(session, task_id, on_status=None, timeout=1800, interval=3):
 
 
 def get_result(session, task_id):
-    """GET the result; return (video_url, output_dict). Raises on moderation block / missing url."""
+    """GET the result. Returns {'videoUrl':…} for video, or {'images':[url,…]} for image. Raises on
+    moderation block / empty output."""
     j = session.request("GET", f"{API}/create/generation-tasks/{task_id}/result").json()
     mod = j.get("moderation_status")
     if mod and mod != "allowed":
         raise RuntimeError(f"moderation blocked: {mod}")
     out = j.get("output") or {}
-    url = out.get("video_url")
-    if not url:
-        raise RuntimeError(f"no video_url in result: {json.dumps(j)[:800]}")
-    return url, out
+    if out.get("video_url"):
+        return {"videoUrl": out["video_url"], "output": out}
+    imgs = [x.get("url") for x in (out.get("images") or []) if isinstance(x, dict) and x.get("url")]
+    if imgs:
+        return {"images": imgs, "output": out}
+    raise RuntimeError(f"no video_url/images in result: {json.dumps(j)[:800]}")
 
 
 def main():
     ap = argparse.ArgumentParser()
     ap.add_argument("--prompt", default="")
-    ap.add_argument("--capability", default="reference-to-video", choices=["reference-to-video", "image-to-video"])
-    ap.add_argument("--model", default="seedance-2.0-pro")
+    ap.add_argument("--capability", default="reference-to-video",
+                    choices=["reference-to-video", "image-to-video", "edit", "text-to-image"])
+    ap.add_argument("--model", default=None, help="defaults by capability: image→seedream-5.0-pro, video→seedance-2.0-pro")
     ap.add_argument("--image-url", action="append", default=[],
-                    help="public image URL. reference-to-video: repeat for ordered refs. image-to-video: first = START frame.")
+                    help="public image URL. reference-to-video: repeat for ordered refs. image-to-video/edit: first = start/source.")
     ap.add_argument("--last-frame-url", default=None, help="image-to-video only: END frame URL (optional)")
+    ap.add_argument("--num", type=int, default=1, help="num_images (image capabilities) — probe >1 here")
+    ap.add_argument("--input-json", default=None,
+                    help="PROBE: raw JSON for args.input verbatim (override the built payload — test undocumented combos)")
     ap.add_argument("--duration", type=int, default=5)
     ap.add_argument("--aspect", default="1:1")
     ap.add_argument("--resolution", default="1080p")
@@ -260,6 +311,8 @@ def main():
         _JSON_OUT = sys.stdout
         sys.stdout = sys.stderr  # any stray print() can't corrupt the event stream
 
+    # model default is capability-aware: image caps use seedream (seedANCE is the VIDEO model — a common mixup).
+    model = args.model or ("seedream-5.0-pro" if args.capability in ("edit", "text-to-image") else "seedance-2.0-pro")
     image_urls = args.image_url or ["https://www.gstatic.com/webp/gallery/1.jpg"]  # default = permissive test image
     sess = BrowserSession(f"http://{args.host}:{args.port}", args.match)
     try:
@@ -269,11 +322,12 @@ def main():
             event(event="progress", phase="rendering", taskId=task_id)
         else:
             task_id = submit(sess, args.prompt, image_urls, args.duration, args.aspect, args.resolution, not args.no_audio,
-                             capability=args.capability, model=args.model, last_frame_url=args.last_frame_url)
+                             capability=args.capability, model=model, last_frame_url=args.last_frame_url,
+                             num_images=args.num, input_json=args.input_json)
             log(f"submitted task {task_id}")
             event(event="progress", phase="submitted", taskId=task_id)
         poll(sess, task_id, on_status=lambda st: (log(f"   status={st}"), event(event="progress", phase=st.lower(), taskId=task_id)))
-        video_url, out = get_result(sess, task_id)
+        res = get_result(sess, task_id)
     except Exception as e:
         event(event="error", reason="tryinfer", detail=str(e))
         log(f"\n❌ {e}")
@@ -281,12 +335,22 @@ def main():
     finally:
         sess.close()
 
-    event(event="done", taskId=task_id, videoUrl=video_url,
-          width=out.get("width"), height=out.get("height"), duration=out.get("duration_seconds"))
-    log(f"\n✅ {out.get('width')}x{out.get('height')}  {out.get('duration_seconds')}s")
-    if not args.emit_json:
-        print(json.dumps({"ok": True, "video_url": video_url, "width": out.get("width"),
-                          "height": out.get("height"), "duration": out.get("duration_seconds")}))
+    if res.get("images"):
+        event(event="done", taskId=task_id, images=res["images"])
+        dims = {x.get("url"): (x.get("width"), x.get("height")) for x in ((res.get("output") or {}).get("images") or []) if isinstance(x, dict)}
+        log(f"\n✅ {len(res['images'])} image(s):")
+        for u in res["images"]:
+            w, h = dims.get(u, (None, None))
+            log(f"   {w}x{h}  {u}")
+        if not args.emit_json:
+            print(json.dumps({"ok": True, "images": res["images"]}))
+    else:
+        out = res.get("output") or {}
+        event(event="done", taskId=task_id, videoUrl=res["videoUrl"],
+              width=out.get("width"), height=out.get("height"), duration=out.get("duration_seconds"))
+        log(f"\n✅ {out.get('width')}x{out.get('height')}  {out.get('duration_seconds')}s")
+        if not args.emit_json:
+            print(json.dumps({"ok": True, "video_url": res["videoUrl"]}))
 
 
 if __name__ == "__main__":