pipelabs-bridge 0.1.0__tar.gz

pipelabs_bridge-0.1.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: pipelabs-bridge
+Version: 0.1.0
+Summary: Pipelabs bridge — connects your local ComfyUI server to Pipelabs.
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31
+Requires-Dist: pillow>=10.0
+
+# pipelabs-bridge
+
+The Pipelabs bridge runs on your ComfyUI server. It connects **outbound** to
+Pipelabs (no inbound ports needed, so it works behind Vast.ai's NAT), polls for
+jobs, talks to your local ComfyUI API, and reports status back.
+
+## Install & run
+
+```bash
+pip install pipelabs-bridge
+pipelabs-bridge --token <YOUR_TOKEN> --app-url https://your-pipelabs-app
+```
+
+Options (all can also be set via environment variables):
+
+| Flag          | Env var             | Default                 |
+| ------------- | ------------------- | ----------------------- |
+| `--token`     | `PIPELABS_TOKEN`    | (required)              |
+| `--app-url`   | `PIPELABS_APP_URL`  | `http://localhost:3000` |
+| `--comfy-url` | `COMFY_URL`         | `http://127.0.0.1:8188` |
+| `--interval`  | —                   | `3.0` (seconds)         |
+| `--max-interval` | —                | `20.0` (seconds, capped at 25) |
+
+Keep it running in `tmux` or `screen` so your server stays "online" in the app.
+
+The bridge polls every `--interval` seconds, then slows to `--max-interval` after
+2 minutes with no jobs, so a new job can take up to that long to start when idle.
+
+Handles every Pipelabs job: health checks, images, reference boards, clips and
+stitching.

pipelabs_bridge-0.1.0/README.md

@@ -0,0 +1,30 @@
+# pipelabs-bridge
+
+The Pipelabs bridge runs on your ComfyUI server. It connects **outbound** to
+Pipelabs (no inbound ports needed, so it works behind Vast.ai's NAT), polls for
+jobs, talks to your local ComfyUI API, and reports status back.
+
+## Install & run
+
+```bash
+pip install pipelabs-bridge
+pipelabs-bridge --token <YOUR_TOKEN> --app-url https://your-pipelabs-app
+```
+
+Options (all can also be set via environment variables):
+
+| Flag          | Env var             | Default                 |
+| ------------- | ------------------- | ----------------------- |
+| `--token`     | `PIPELABS_TOKEN`    | (required)              |
+| `--app-url`   | `PIPELABS_APP_URL`  | `http://localhost:3000` |
+| `--comfy-url` | `COMFY_URL`         | `http://127.0.0.1:8188` |
+| `--interval`  | —                   | `3.0` (seconds)         |
+| `--max-interval` | —                | `20.0` (seconds, capped at 25) |
+
+Keep it running in `tmux` or `screen` so your server stays "online" in the app.
+
+The bridge polls every `--interval` seconds, then slows to `--max-interval` after
+2 minutes with no jobs, so a new job can take up to that long to start when idle.
+
+Handles every Pipelabs job: health checks, images, reference boards, clips and
+stitching.

pipelabs_bridge-0.1.0/pipelabs_bridge/__init__.py

@@ -0,0 +1,3 @@
+"""Pipelabs bridge package."""
+
+__version__ = "0.1.0"

pipelabs_bridge-0.1.0/pipelabs_bridge/cli.py

@@ -0,0 +1,31 @@
+import argparse
+import os
+
+from .client import BridgeClient
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(
+        prog="pipelabs-bridge",
+        description="Connect your local ComfyUI server to Pipelabs.",
+    )
+    p.add_argument("--token", default=os.environ.get("PIPELABS_TOKEN"),
+                   help="Your connection token from the Pipelabs Connect page.")
+    p.add_argument("--app-url", default=os.environ.get("PIPELABS_APP_URL", "http://localhost:3000"),
+                   help="Base URL of the Pipelabs app.")
+    p.add_argument("--comfy-url", default=os.environ.get("COMFY_URL", "http://127.0.0.1:8188"),
+                   help="Base URL of your local ComfyUI API.")
+    p.add_argument("--interval", type=float, default=3.0,
+                   help="Seconds between polls while active (default: 3).")
+    p.add_argument("--max-interval", type=float, default=20.0,
+                   help="Seconds between polls once idle for 2 minutes (default: 20, capped at 25).")
+    args = p.parse_args()
+
+    if not args.token:
+        p.error("--token is required (or set PIPELABS_TOKEN).")
+
+    BridgeClient(args.token, args.app_url, args.comfy_url, args.interval, args.max_interval).run()
+
+
+if __name__ == "__main__":
+    main()

pipelabs_bridge-0.1.0/pipelabs_bridge/client.py

@@ -0,0 +1,109 @@
+import time
+import traceback
+
+import requests
+
+from . import health, runner
+from .comfy import ComfyClient
+from .pacer import PollPacer
+
+
+class BridgeClient:
+    def __init__(self, token: str, app_url: str, comfy_url: str, interval: float = 3.0,
+                 max_interval: float = 20.0):
+        self.app_url = app_url.rstrip("/")
+        self.comfy = ComfyClient(comfy_url)
+        self.pacer = PollPacer(base=interval, max_delay=max_interval)
+        self.s = requests.Session()
+        self.s.headers["Authorization"] = f"Bearer {token}"
+
+    def _url(self, path: str) -> str:
+        return f"{self.app_url}{path}"
+
+    def hello(self) -> None:
+        try:
+            self.s.post(self._url("/api/bridge/hello"),
+                        json={"comfy": self.comfy.ping()}, timeout=15)
+            print(f"[pipelabs] connected to {self.app_url}")
+        except Exception as e:  # noqa: BLE001
+            print(f"[pipelabs] hello failed: {e}")
+
+    def run(self) -> None:
+        print(f"[pipelabs] starting bridge; ComfyUI at {self.comfy.base}")
+        self.hello()
+        while True:
+            try:
+                r = self.s.get(self._url("/api/bridge/jobs"), timeout=30)
+                job = r.json().get("job") if r.ok else None
+                if job:
+                    self.handle(job)
+                    self.pacer.job_seen()
+                # (A successful GET /jobs already counts as a heartbeat server-side.)
+            except Exception as e:  # noqa: BLE001
+                print(f"[pipelabs] poll error: {e}")
+            time.sleep(self.pacer.next_delay())
+
+    def handle(self, job: dict) -> None:
+        jid, jtype = job["id"], job["type"]
+        payload = job.get("payload") or {}
+        print(f"[pipelabs] job {jid} ({jtype})")
+
+        def progress(pct, logs=""):
+            self.progress(jid, pct, logs)
+
+        try:
+            if jtype == "HEALTH_CHECK":
+                self.result(jid, True, health.collect(self.comfy, payload))
+                return
+
+            # Generation jobs run whatever patched workflow the app sends.
+            workflow = payload.get("workflow")
+            if jtype == "GENERATE_IMAGE":
+                if not workflow:
+                    self.result(jid, False, {
+                        "error": "No workflow attached to this job."})
+                elif payload.get("extractStills"):
+                    # Base image via text-to-video: run, then pull still frames.
+                    self.result(jid, True, runner.run_image_via_video(
+                        self.comfy, workflow, int(payload["extractStills"]), progress))
+                else:
+                    self.result(jid, True, runner.run_image_workflow(self.comfy, workflow, progress))
+            elif jtype == "GENERATE_CLIP":
+                if not workflow:
+                    self.result(jid, False, {"error": "No workflow attached to this job."})
+                else:
+                    pics = payload.get("pictures") or []
+                    if pics:
+                        node = payload.get("mediaNodeId", "416")
+                        workflow[node]["inputs"]["media_state"] = runner.build_media_state(self.comfy, pics)
+                    res = runner.run_clip(self.comfy, workflow, progress)
+                    self.result(jid, res.get("ok", False), res)
+            elif jtype == "REFERENCE_BOARD":
+                if not workflow:
+                    self.result(jid, False, {"error": "No workflow attached to this job."})
+                else:
+                    res = runner.run_reference_board(self.comfy, workflow, payload, progress)
+                    self.result(jid, res.get("ok", False), res)
+            elif jtype == "STITCH":
+                res = runner.run_stitch(self.comfy, payload, progress)
+                self.result(jid, res.get("ok", False), res)
+            else:
+                self.result(jid, False,
+                            {"error": f"{jtype} is not supported by this bridge version yet."})
+        except Exception as e:  # noqa: BLE001
+            traceback.print_exc()
+            self.result(jid, False, {"error": str(e)})
+
+    def progress(self, jid: str, pct: int, logs: str = "") -> None:
+        try:
+            self.s.post(self._url(f"/api/bridge/jobs/{jid}/progress"),
+                        json={"progress": pct, "logs": logs}, timeout=15)
+        except Exception as e:  # noqa: BLE001
+            print(f"[pipelabs] progress error: {e}")
+
+    def result(self, jid: str, ok: bool, data: dict) -> None:
+        try:
+            self.s.post(self._url(f"/api/bridge/jobs/{jid}/result"),
+                        json={"ok": ok, "result": data}, timeout=30)
+        except Exception as e:  # noqa: BLE001
+            print(f"[pipelabs] result error: {e}")

pipelabs_bridge-0.1.0/pipelabs_bridge/comfy.py

@@ -0,0 +1,67 @@
+import os
+import uuid
+
+import requests
+
+
+class ComfyClient:
+    """Thin wrapper around the local ComfyUI HTTP API."""
+
+    def __init__(self, base: str):
+        self.base = base.rstrip("/")
+        self.client_id = str(uuid.uuid4())
+
+    # --- Status / introspection ------------------------------------------
+    def ping(self) -> dict:
+        """Check that ComfyUI is reachable; include system stats when it is."""
+        try:
+            r = requests.get(f"{self.base}/system_stats", timeout=10)
+            if r.ok:
+                return {"reachable": True, "system": r.json()}
+            return {"reachable": False, "error": f"HTTP {r.status_code}"}
+        except Exception as e:  # noqa: BLE001
+            return {"reachable": False, "error": str(e)}
+
+    def object_info(self) -> dict:
+        """Map of available node class_type -> definition."""
+        r = requests.get(f"{self.base}/object_info", timeout=30)
+        r.raise_for_status()
+        return r.json()
+
+    # --- Execution -------------------------------------------------------
+    def upload_image(self, filepath: str, subfolder: str = "minimax_h3", overwrite: bool = True) -> dict:
+        """Upload a local file into ComfyUI's input dir. Returns {name, subfolder, type}."""
+        with open(filepath, "rb") as f:
+            files = {"image": (os.path.basename(filepath), f, "application/octet-stream")}
+            data = {"subfolder": subfolder, "type": "input", "overwrite": "true" if overwrite else "false"}
+            r = requests.post(f"{self.base}/upload/image", files=files, data=data, timeout=120)
+        r.raise_for_status()
+        return r.json()
+
+    def queue_prompt(self, workflow: dict) -> str:
+        """Queue an API-format workflow. Returns the prompt_id."""
+        payload = {"prompt": workflow, "client_id": self.client_id}
+        r = requests.post(f"{self.base}/prompt", json=payload, timeout=60)
+        if not r.ok:
+            # ComfyUI returns a helpful validation error body on 400.
+            raise RuntimeError(f"ComfyUI rejected the workflow ({r.status_code}): {r.text[:500]}")
+        return r.json()["prompt_id"]
+
+    def history(self, prompt_id: str) -> dict:
+        r = requests.get(f"{self.base}/history/{prompt_id}", timeout=30)
+        r.raise_for_status()
+        return r.json()
+
+    def queue_state(self) -> dict:
+        try:
+            r = requests.get(f"{self.base}/queue", timeout=15)
+            return r.json() if r.ok else {}
+        except Exception:  # noqa: BLE001
+            return {}
+
+    def view(self, filename: str, subfolder: str = "", folder_type: str = "output") -> bytes:
+        """Fetch an output/temp/input file's bytes."""
+        params = {"filename": filename, "subfolder": subfolder, "type": folder_type}
+        r = requests.get(f"{self.base}/view", params=params, timeout=120)
+        r.raise_for_status()
+        return r.content

pipelabs_bridge-0.1.0/pipelabs_bridge/health.py

@@ -0,0 +1,77 @@
+import os
+import shutil
+import subprocess
+
+
+def _gpu() -> dict:
+    try:
+        out = subprocess.check_output(
+            ["nvidia-smi", "--query-gpu=name,memory.total,memory.free",
+             "--format=csv,noheader,nounits"],
+            timeout=10,
+        ).decode().strip()
+        name, total, free = [x.strip() for x in out.splitlines()[0].split(",")]
+        return {"name": name, "totalMB": int(total), "freeMB": int(free)}
+    except Exception as e:  # noqa: BLE001
+        return {"error": str(e)}
+
+
+def _disk(path: str = "/") -> dict:
+    try:
+        u = shutil.disk_usage(path)
+        return {"path": path, "freeGB": round(u.free / 1e9, 1), "totalGB": round(u.total / 1e9, 1)}
+    except Exception as e:  # noqa: BLE001
+        return {"error": str(e)}
+
+
+def _basename(p: str) -> str:
+    return os.path.basename(str(p).replace("\\", "/"))
+
+
+def _available_files(info: dict) -> set:
+    """All filenames ComfyUI offers in loader dropdowns (from /object_info).
+
+    Each input spec looks like [<combo_list>, {...}] where <combo_list> is a
+    list of selectable strings (model filenames for loaders).
+    """
+    names = set()
+    for node_def in info.values():
+        if not isinstance(node_def, dict):
+            continue
+        inp = node_def.get("input") or {}
+        for group in ("required", "optional"):
+            for spec in (inp.get(group) or {}).values():
+                if isinstance(spec, list) and spec and isinstance(spec[0], list):
+                    for opt in spec[0]:
+                        if isinstance(opt, str):
+                            names.add(opt)
+    return names
+
+
+def collect(comfy, payload: dict) -> dict:
+    """Run the health check and return a result the app knows how to display."""
+    ping = comfy.ping()
+    result = {"comfy": ping, "gpu": _gpu(), "disk": _disk()}
+
+    required_nodes = payload.get("requiredNodes") or []
+    required_models = payload.get("requiredModels") or []
+
+    nodes, models = [], []
+    if (required_nodes or required_models) and ping.get("reachable"):
+        try:
+            info = comfy.object_info()
+            # Custom node presence
+            nodes = [{"name": n, "present": n in info} for n in required_nodes]
+            # Model presence, matched by basename against loader dropdowns
+            avail = {_basename(x) for x in _available_files(info)}
+            for m in required_models:
+                base = _basename(m.get("path") or m.get("name") or "")
+                models.append({"name": m.get("name"), "present": base in avail})
+        except Exception as e:  # noqa: BLE001
+            err = str(e)
+            nodes = [{"name": n, "present": False, "error": err} for n in required_nodes]
+            models = [{"name": m.get("name"), "present": False, "error": err} for m in required_models]
+
+    result["nodes"] = nodes
+    result["models"] = models
+    return result

pipelabs_bridge-0.1.0/pipelabs_bridge/pacer.py

@@ -0,0 +1,37 @@
+"""Decides how long the bridge waits between polls for jobs.
+
+Polling costs the app's operator a request and database writes every time, so the
+bridge slows down when nothing is happening. It stays fast for a while after a job
+because the user is probably still working and about to queue the next one.
+"""
+import time
+
+# The app shows a server as offline after 35 seconds without contact. Stay well
+# under that so one slow or failed poll doesn't make it flicker.
+MAX_SAFE_DELAY = 25.0
+
+
+class PollPacer:
+    def __init__(self, base: float = 3.0, max_delay: float = 20.0,
+                 hold_seconds: float = 120.0, growth: float = 1.5, now=time.monotonic):
+        self.base = base
+        # Never below the requested base, and capped to keep the server "online"
+        # (unless the user explicitly asked for a base slower than the cap).
+        self.max_delay = max(base, min(max_delay, MAX_SAFE_DELAY))
+        self.hold_seconds = hold_seconds
+        self.growth = growth
+        self._now = now
+        self._delay = base
+        self._active_at = now()
+
+    def job_seen(self) -> None:
+        """Call when a job finishes: go back to fast polling."""
+        self._active_at = self._now()
+        self._delay = self.base
+
+    def next_delay(self) -> float:
+        """Seconds to wait before the next poll."""
+        if self._now() - self._active_at < self.hold_seconds:
+            return self.base
+        self._delay = min(self.max_delay, self._delay * self.growth)
+        return self._delay

pipelabs_bridge-0.1.0/pipelabs_bridge/runner.py

@@ -0,0 +1,398 @@
+"""Generic ComfyUI workflow execution: queue an API-format workflow, wait for
+it, collect image/video outputs, and (for characters) build reference boards.
+
+Workflow-agnostic — the app patches a workflow and sends it in the job payload;
+this just runs whatever it's given. Frame extraction and the board montage need
+ffmpeg + Pillow on the server.
+"""
+
+import base64
+import copy
+import datetime
+import glob
+import io
+import json
+import os
+import subprocess
+import tempfile
+import time
+
+try:
+    from PIL import Image, ImageDraw
+    _HAS_PIL = True
+except Exception:  # noqa: BLE001
+    _HAS_PIL = False
+
+
+def _thumbnail(data: bytes, size: int = 256) -> str | None:
+    if not _HAS_PIL:
+        return None
+    try:
+        im = Image.open(io.BytesIO(data)).convert("RGB")
+        im.thumbnail((size, size))
+        buf = io.BytesIO()
+        im.save(buf, format="JPEG", quality=70)
+        return "data:image/jpeg;base64," + base64.b64encode(buf.getvalue()).decode()
+    except Exception:  # noqa: BLE001
+        return None
+
+
+PROGRESS_REPORT_SECONDS = 15
+
+
+def _wait(comfy, prompt_id: str, on_progress=None, timeout: int = 1800) -> dict:
+    start = time.time()
+    last_report = 0.0
+    while True:
+        hist = comfy.history(prompt_id)
+        if prompt_id in hist:
+            return hist[prompt_id]
+        # ComfyUI is local, so checking it often is free. Reports to the app are not,
+        # but they double as the heartbeat, so keep them under its 35 s online window.
+        if on_progress and time.time() - last_report >= PROGRESS_REPORT_SECONDS:
+            last_report = time.time()
+            q = comfy.queue_state()
+            running = len(q.get("queue_running", []))
+            pending = len(q.get("queue_pending", []))
+            on_progress(5, f"queued (running={running}, pending={pending})")
+        if time.time() - start > timeout:
+            raise TimeoutError("Workflow timed out")
+        time.sleep(2)
+
+
+def _collect(comfy, outputs: dict):
+    images, videos, thumbs = [], [], {}
+    for out in outputs.values():
+        for img in out.get("images", []) or []:
+            if img.get("type") == "temp":
+                continue
+            ref = f"{img.get('subfolder', '')}/{img['filename']}".lstrip("/")
+            images.append(ref)
+            try:
+                thumbs[ref] = _thumbnail(comfy.view(img["filename"], img.get("subfolder", ""), img.get("type", "output")))
+            except Exception:  # noqa: BLE001
+                pass
+        for vid in out.get("gifs", []) or []:  # VHS_VideoCombine mp4/webm
+            ref = f"{vid.get('subfolder', '')}/{vid['filename']}".lstrip("/")
+            videos.append(ref)
+    return images, videos, thumbs
+
+
+def _extract_frames(comfy, video_ref: str, outdir: str) -> list:
+    """Download an output video and ffmpeg-extract its frames into outdir."""
+    subfolder, _, filename = video_ref.rpartition("/")
+    data = comfy.view(filename, subfolder, "output")
+    mp4 = os.path.join(outdir, "clip.mp4")
+    with open(mp4, "wb") as f:
+        f.write(data)
+    subprocess.run(
+        ["ffmpeg", "-y", "-i", mp4, os.path.join(outdir, "f_%05d.png")],
+        check=True, capture_output=True, timeout=180,
+    )
+    return sorted(glob.glob(os.path.join(outdir, "f_*.png")))
+
+
+def run_image_workflow(comfy, workflow: dict, on_progress=None) -> dict:
+    prompt_id = comfy.queue_prompt(workflow)
+    if on_progress:
+        on_progress(10, "queued")
+    data = _wait(comfy, prompt_id, on_progress)
+    images, _videos, thumbs = _collect(comfy, data.get("outputs", {}))
+    return {"candidates": images, "thumbnails": thumbs, "prompt_id": prompt_id}
+
+
+def run_video_workflow(comfy, workflow: dict, on_progress=None) -> dict:
+    prompt_id = comfy.queue_prompt(workflow)
+    if on_progress:
+        on_progress(10, "queued")
+    data = _wait(comfy, prompt_id, on_progress)
+    images, videos, thumbs = _collect(comfy, data.get("outputs", {}))
+    return {"videos": videos, "stills": images, "thumbnails": thumbs, "prompt_id": prompt_id}
+
+
+def run_image_via_video(comfy, workflow: dict, extract: int = 3, on_progress=None) -> dict:
+    """Run a text-to-video workflow, then pull `extract` still frames as base-image
+    candidates (uploaded back into ComfyUI's input dir for reuse)."""
+    res = run_video_workflow(comfy, workflow, on_progress)
+    videos = res.get("videos") or []
+    if not videos:
+        return {"candidates": [], "thumbnails": {}, "error": "the workflow produced no video output"}
+    if on_progress:
+        on_progress(90, "extracting frames")
+
+    candidates, thumbs = [], {}
+    with tempfile.TemporaryDirectory() as td:
+        try:
+            frames = _extract_frames(comfy, videos[0], td)
+        except Exception as e:  # noqa: BLE001
+            return {"candidates": [], "thumbnails": {}, "error": f"frame extraction failed (is ffmpeg installed?): {e}"}
+        if not frames:
+            return {"candidates": [], "thumbnails": {}, "error": "no frames extracted"}
+
+        if extract <= 1:
+            picks = [frames[len(frames) // 2]]
+        elif len(frames) <= extract:
+            picks = frames
+        else:
+            picks = [frames[round(k * (len(frames) - 1) / (extract - 1))] for k in range(extract)]
+
+        for p in picks:
+            up = comfy.upload_image(p, subfolder="minimax_h3")
+            cref = f"{up.get('subfolder', '')}/{up.get('name')}".lstrip("/")
+            candidates.append(cref)
+            try:
+                with open(p, "rb") as fh:
+                    thumbs[cref] = _thumbnail(fh.read())
+            except Exception:  # noqa: BLE001
+                pass
+    return {"candidates": candidates, "thumbnails": thumbs}
+
+
+def build_media_state(comfy, refs: list) -> str:
+    """Build a MiniMaxH3MediaLoader media_state from uploaded input-dir refs,
+    reading each image's dimensions."""
+    entries = []
+    for i, ref in enumerate(refs):
+        subfolder, _, filename = str(ref).rpartition("/")
+        try:
+            w, h = Image.open(io.BytesIO(comfy.view(filename, subfolder, "input"))).size
+        except Exception:  # noqa: BLE001
+            w, h = 0, 0
+        entries.append({
+            "kind": "picture", "file": f"{ref} [input]", "name": filename,
+            "duration": None, "width": w, "height": h, "has_audio": False,
+            "audio_mode": "off", "uid": f"ref{i}",
+        })
+    return json.dumps(entries)
+
+
+def run_clip(comfy, workflow: dict, on_progress=None) -> dict:
+    """Render one scenario clip; return the output video ref + a thumbnail."""
+    res = run_video_workflow(comfy, workflow, on_progress)
+    vids = res.get("videos") or []
+    if not vids:
+        return {"ok": False, "error": "the workflow produced no video output"}
+    out = {"ok": True, "outputRef": vids[0]}
+    try:
+        with tempfile.TemporaryDirectory() as td:
+            frames = _extract_frames(comfy, vids[0], td)
+            if frames:
+                with open(frames[len(frames) // 2], "rb") as fh:
+                    out["thumbnail"] = _thumbnail(fh.read())
+    except Exception:  # noqa: BLE001
+        pass
+    return out
+
+
+def _make_board(labeled: list, cols: int = 2, cell: int = 512, pad: int = 12, label_h: int = 28) -> bytes:
+    """Tile (name, image_bytes) pairs into one labeled board PNG."""
+    n = len(labeled)
+    rows = (n + cols - 1) // cols
+    W = cols * cell + (cols + 1) * pad
+    H = rows * (cell + label_h) + (rows + 1) * pad
+    board = Image.new("RGB", (W, H), (20, 24, 33))
+    draw = ImageDraw.Draw(board)
+    for idx, (name, data) in enumerate(labeled):
+        im = Image.open(io.BytesIO(data)).convert("RGB")
+        im.thumbnail((cell, cell))
+        r, c = divmod(idx, cols)
+        x = pad + c * (cell + pad)
+        y = pad + r * (cell + label_h + pad)
+        board.paste(im, (x + (cell - im.width) // 2, y))
+        draw.text((x, y + cell + 6), name, fill=(230, 233, 239))
+    buf = io.BytesIO()
+    board.save(buf, format="PNG")
+    return buf.getvalue()
+
+
+def run_reference_board(comfy, base_workflow: dict, payload: dict, on_progress=None) -> dict:
+    """Render one short clip per angle (each referencing the base image as
+    <Picture 1>), take the middle frame of each, and montage them into a board
+    image stored on the user's server."""
+    prompt_node = payload.get("promptNodeId", "365")
+    media_node = payload.get("mediaNodeId", "416")
+    seed_node = payload.get("seedNodeId", "16")
+    base_ref = payload.get("baseImageRef")
+    angles = payload.get("angles") or []
+    seed_base = int(payload.get("seedBase") or 0)
+
+    if not base_ref or not angles:
+        return {"ok": False, "error": "missing base image or angles"}
+
+    # Build media_state for the base image (needs its dimensions).
+    subfolder, _, filename = base_ref.rpartition("/")
+    base_bytes = comfy.view(filename, subfolder, "input")
+    w, h = Image.open(io.BytesIO(base_bytes)).size
+    media_state = json.dumps([{
+        "kind": "picture", "file": f"{base_ref} [input]", "name": filename,
+        "duration": None, "width": w, "height": h, "has_audio": False,
+        "audio_mode": "off", "uid": "base0",
+    }])
+
+    labeled = []
+    total = len(angles)
+    for i, angle in enumerate(angles):
+        wf = copy.deepcopy(base_workflow)
+        wf[media_node]["inputs"]["media_state"] = media_state
+        wf[prompt_node]["inputs"]["prompt"] = angle["prompt"]
+        if seed_node in wf:
+            wf[seed_node]["inputs"]["seed"] = seed_base + i
+        if on_progress:
+            on_progress(int(10 + 70 * i / max(1, total)), f"rendering {angle['name']}")
+        res = run_video_workflow(comfy, wf)
+        vids = res.get("videos") or []
+        if not vids:
+            return {"ok": False, "error": f"no video output for {angle['name']}"}
+        with tempfile.TemporaryDirectory() as td:
+            frames = _extract_frames(comfy, vids[0], td)
+            if not frames:
+                return {"ok": False, "error": f"no frames for {angle['name']}"}
+            with open(frames[len(frames) // 2], "rb") as fh:
+                labeled.append((angle["name"], fh.read()))
+
+    if on_progress:
+        on_progress(90, "combining board")
+    board_png = _make_board(labeled)
+    with tempfile.TemporaryDirectory() as td:
+        bp = os.path.join(td, "board.png")
+        with open(bp, "wb") as f:
+            f.write(board_png)
+        up = comfy.upload_image(bp, subfolder="minimax_h3")
+        board_ref = f"{up.get('subfolder', '')}/{up.get('name')}".lstrip("/")
+
+    return {"ok": True, "boardRef": board_ref, "thumbnail": _thumbnail(board_png)}
+
+
+# --- Stitch / export (feature 7) --------------------------------------------
+
+def _duration(path: str) -> float:
+    out = subprocess.check_output(
+        ["ffprobe", "-v", "error", "-show_entries", "format=duration",
+         "-of", "default=nw=1:nk=1", path],
+        timeout=30,
+    ).decode().strip()
+    return float(out)
+
+
+def _simple_concat(clips: list, out: str, td: str) -> None:
+    listf = os.path.join(td, "list.txt")
+    with open(listf, "w") as f:
+        for p in clips:
+            f.write(f"file '{p}'\n")
+    subprocess.run(
+        ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", listf,
+         "-c:v", "libx264", "-c:a", "aac", "-pix_fmt", "yuv420p", out],
+        check=True, capture_output=True, timeout=900,
+    )
+
+
+def _xfade_concat(clips: list, out: str, xf: float) -> None:
+    durs = [_duration(p) for p in clips]
+    inputs = []
+    for p in clips:
+        inputs += ["-i", p]
+    filters = []
+    cur_v, cur_a, t = "[0:v]", "[0:a]", durs[0]
+    for i in range(1, len(clips)):
+        off = max(0.0, t - xf)
+        nv, na = f"[v{i}]", f"[a{i}]"
+        filters.append(f"{cur_v}[{i}:v]xfade=transition=fade:duration={xf}:offset={off}{nv}")
+        filters.append(f"{cur_a}[{i}:a]acrossfade=d={xf}{na}")
+        cur_v, cur_a, t = nv, na, t + durs[i] - xf
+    subprocess.run(
+        ["ffmpeg", "-y", *inputs, "-filter_complex", ";".join(filters),
+         "-map", cur_v, "-map", cur_a, "-c:v", "libx264", "-c:a", "aac", "-pix_fmt", "yuv420p", out],
+        check=True, capture_output=True, timeout=1200,
+    )
+
+
+def _add_music(video: str, music: str, out: str) -> None:
+    subprocess.run(
+        ["ffmpeg", "-y", "-i", video, "-i", music,
+         "-filter_complex", "[0:a][1:a]amix=inputs=2:duration=first:dropout_transition=2[a]",
+         "-map", "0:v", "-map", "[a]", "-c:v", "copy", "-c:a", "aac", out],
+        check=True, capture_output=True, timeout=600,
+    )
+
+
+def _export_aspect(src: str, out: str, aspect: str) -> None:
+    if aspect == "9:16":
+        vf = "scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920"
+        subprocess.run(
+            ["ffmpeg", "-y", "-i", src, "-vf", vf, "-c:v", "libx264", "-c:a", "copy", "-pix_fmt", "yuv420p", out],
+            check=True, capture_output=True, timeout=600,
+        )
+    else:  # 16:9 — already widescreen, just finalize the container
+        subprocess.run(["ffmpeg", "-y", "-i", src, "-c", "copy", out], check=True, capture_output=True, timeout=300)
+
+
+def run_stitch(comfy, payload: dict, on_progress=None) -> dict:
+    """Concatenate ordered clips (optional crossfade + music), then export the
+    requested aspect ratios. Files are written to ./pipelabs_exports and their
+    absolute paths are reported back. Requires ffmpeg + ffprobe."""
+    clip_refs = payload.get("clips") or []
+    if not clip_refs:
+        return {"ok": False, "error": "no rendered clips to stitch"}
+    cross = payload.get("crossfade") or {}
+    xf = float(cross.get("duration") or 0) if cross.get("enabled") else 0.0
+    music_ref = payload.get("music")
+    aspects = payload.get("aspects") or ["16:9", "9:16"]
+    prefix = payload.get("filenamePrefix") or "pipelabs_export"
+
+    try:
+        with tempfile.TemporaryDirectory() as td:
+            if on_progress:
+                on_progress(10, "downloading clips")
+            local = []
+            for i, ref in enumerate(clip_refs):
+                sub, _, fn = str(ref).rpartition("/")
+                p = os.path.join(td, f"c{i:03d}.mp4")
+                with open(p, "wb") as f:
+                    f.write(comfy.view(fn, sub, "output"))
+                local.append(p)
+
+            music_path = None
+            if music_ref:
+                sub, _, fn = str(music_ref).rpartition("/")
+                for ftype in ("input", "output"):
+                    try:
+                        data = comfy.view(fn, sub, ftype)
+                        music_path = os.path.join(td, "music" + (os.path.splitext(fn)[1] or ".mp3"))
+                        with open(music_path, "wb") as f:
+                            f.write(data)
+                        break
+                    except Exception:  # noqa: BLE001
+                        continue
+
+            if on_progress:
+                on_progress(40, "concatenating")
+            base = os.path.join(td, "base.mp4")
+            if xf > 0 and len(local) > 1:
+                _xfade_concat(local, base, xf)
+            else:
+                _simple_concat(local, base, td)
+
+            if music_path:
+                if on_progress:
+                    on_progress(60, "adding music")
+                mixed = os.path.join(td, "base_music.mp4")
+                _add_music(base, music_path, mixed)
+                base = mixed
+
+            out_dir = os.path.abspath("pipelabs_exports")
+            os.makedirs(out_dir, exist_ok=True)
+            stamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+            outputs = {}
+            for a in aspects:
+                if on_progress:
+                    on_progress(80, f"exporting {a}")
+                outp = os.path.join(out_dir, f"{prefix}_{a.replace(':', 'x')}_{stamp}.mp4")
+                _export_aspect(base, outp, a)
+                outputs[a] = outp
+
+        return {"ok": True, "outputs": outputs}
+    except subprocess.CalledProcessError as e:
+        err = (e.stderr or b"").decode()[-500:]
+        return {"ok": False, "error": f"ffmpeg failed: {err}"}
+    except Exception as e:  # noqa: BLE001
+        return {"ok": False, "error": str(e)}

pipelabs_bridge-0.1.0/pipelabs_bridge.egg-info/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: pipelabs-bridge
+Version: 0.1.0
+Summary: Pipelabs bridge — connects your local ComfyUI server to Pipelabs.
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31
+Requires-Dist: pillow>=10.0
+
+# pipelabs-bridge
+
+The Pipelabs bridge runs on your ComfyUI server. It connects **outbound** to
+Pipelabs (no inbound ports needed, so it works behind Vast.ai's NAT), polls for
+jobs, talks to your local ComfyUI API, and reports status back.
+
+## Install & run
+
+```bash
+pip install pipelabs-bridge
+pipelabs-bridge --token <YOUR_TOKEN> --app-url https://your-pipelabs-app
+```
+
+Options (all can also be set via environment variables):
+
+| Flag          | Env var             | Default                 |
+| ------------- | ------------------- | ----------------------- |
+| `--token`     | `PIPELABS_TOKEN`    | (required)              |
+| `--app-url`   | `PIPELABS_APP_URL`  | `http://localhost:3000` |
+| `--comfy-url` | `COMFY_URL`         | `http://127.0.0.1:8188` |
+| `--interval`  | —                   | `3.0` (seconds)         |
+| `--max-interval` | —                | `20.0` (seconds, capped at 25) |
+
+Keep it running in `tmux` or `screen` so your server stays "online" in the app.
+
+The bridge polls every `--interval` seconds, then slows to `--max-interval` after
+2 minutes with no jobs, so a new job can take up to that long to start when idle.
+
+Handles every Pipelabs job: health checks, images, reference boards, clips and
+stitching.

pipelabs_bridge-0.1.0/pipelabs_bridge.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+pipelabs_bridge/__init__.py
+pipelabs_bridge/cli.py
+pipelabs_bridge/client.py
+pipelabs_bridge/comfy.py
+pipelabs_bridge/health.py
+pipelabs_bridge/pacer.py
+pipelabs_bridge/runner.py
+pipelabs_bridge.egg-info/PKG-INFO
+pipelabs_bridge.egg-info/SOURCES.txt
+pipelabs_bridge.egg-info/dependency_links.txt
+pipelabs_bridge.egg-info/entry_points.txt
+pipelabs_bridge.egg-info/requires.txt
+pipelabs_bridge.egg-info/top_level.txt
+tests/test_pacer.py

pipelabs_bridge-0.1.0/pipelabs_bridge.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pipelabs_bridge-0.1.0/pipelabs_bridge.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pipelabs-bridge = pipelabs_bridge.cli:main

pipelabs_bridge-0.1.0/pipelabs_bridge.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests>=2.31
+pillow>=10.0

pipelabs_bridge-0.1.0/pipelabs_bridge.egg-info/top_level.txt

@@ -0,0 +1 @@
+pipelabs_bridge

pipelabs_bridge-0.1.0/pyproject.toml

@@ -0,0 +1,17 @@
+[project]
+name = "pipelabs-bridge"
+version = "0.1.0"
+description = "Pipelabs bridge — connects your local ComfyUI server to Pipelabs."
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = ["requests>=2.31", "pillow>=10.0"]
+
+[project.scripts]
+pipelabs-bridge = "pipelabs_bridge.cli:main"
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["pipelabs_bridge"]

pipelabs_bridge-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pipelabs_bridge-0.1.0/tests/test_pacer.py

@@ -0,0 +1,56 @@
+"""Run from bridge/: python -m unittest discover tests"""
+import unittest
+
+from pipelabs_bridge.pacer import MAX_SAFE_DELAY, PollPacer
+
+
+class FakeClock:
+    def __init__(self):
+        self.t = 0.0
+
+    def __call__(self):
+        return self.t
+
+
+class PollPacerTest(unittest.TestCase):
+    def setUp(self):
+        self.clock = FakeClock()
+        self.pacer = PollPacer(base=3.0, max_delay=20.0, hold_seconds=120.0, now=self.clock)
+
+    def test_stays_fast_during_hold(self):
+        self.clock.t = 119.0
+        self.assertEqual(self.pacer.next_delay(), 3.0)
+
+    def test_slows_down_after_hold(self):
+        self.clock.t = 120.0
+        self.assertEqual(self.pacer.next_delay(), 4.5)
+        self.assertEqual(self.pacer.next_delay(), 6.75)
+
+    def test_never_exceeds_max(self):
+        self.clock.t = 500.0
+        delays = [self.pacer.next_delay() for _ in range(20)]
+        self.assertEqual(delays[-1], 20.0)
+        self.assertLessEqual(max(delays), 20.0)
+
+    def test_job_returns_to_fast_polling(self):
+        self.clock.t = 500.0
+        for _ in range(20):
+            self.pacer.next_delay()
+        self.pacer.job_seen()
+        self.assertEqual(self.pacer.next_delay(), 3.0)
+        self.clock.t = 619.0
+        self.assertEqual(self.pacer.next_delay(), 3.0)
+        self.clock.t = 620.0
+        self.assertEqual(self.pacer.next_delay(), 4.5)
+
+    def test_max_is_capped_to_stay_online(self):
+        pacer = PollPacer(base=3.0, max_delay=600.0, now=self.clock)
+        self.assertEqual(pacer.max_delay, MAX_SAFE_DELAY)
+
+    def test_slow_base_is_respected(self):
+        pacer = PollPacer(base=60.0, max_delay=20.0, hold_seconds=0.0, now=self.clock)
+        self.assertEqual(pacer.next_delay(), 60.0)
+
+
+if __name__ == "__main__":
+    unittest.main()