storyboard-bridge 0.3.7 → 0.4.0

package/index.mjs

@@ -40,6 +40,8 @@ const VERSION = createRequire(import.meta.url)('./package.json').version;
 // in-flight Higgsfield render children, keyed by job id — so a `higgsfield-cancel` can kill the right one
 // (the backend sends it when the user cancels, freeing the single render slot instead of leaving it running).
 const hfChildren = new Map();
+// in-flight official-CLI render children (the `higgsfield-cli` credit-billed path — separate from the CDP one).
+const hfCliChildren = new Map();
 
 // ---- config ----
 const arg = (name, fallback) => {
@@ -63,6 +65,8 @@ const HIGGSFIELD = process.argv.includes('--higgsfield') || process.env.STORYBOA
 // Opt out with --no-own-rights or STORYBOARD_OWN_RIGHTS=0.
 const OWN_RIGHTS = !(process.argv.includes('--no-own-rights') || process.env.STORYBOARD_OWN_RIGHTS === '0');
 const PYTHON_BIN = arg('python-bin', process.env.PYTHON_BIN || (IS_WIN ? 'python.exe' : 'python3'));
+// the official Higgsfield CLI (credit-billed i2v). Available iff installed + `higgsfield auth login` done.
+const HF_CLI = arg('higgsfield-cli-bin', process.env.HIGGSFIELD_CLI_BIN || 'higgsfield');
 const CDP_HTTP = arg('cdp', process.env.CDP_HTTP || 'http://localhost:9222'); // the debug Chrome endpoint
 const HF_SCRIPT = join(dirname(fileURLToPath(import.meta.url)), 'higgsfield_client.py');
 // claude supports `--output-format json` (wraps as {result}); gemini's CLI (<=0.1.x) does NOT — it
@@ -229,12 +233,12 @@ async function handleHiggsfield(msg, ws) {
         ws.send(JSON.stringify({ type: 'hfEvent', id, ...ev })); // forward progress/verified/done/error
       }
     });
-    child.stderr.on('data', (d) => { stderrTail = (stderrTail + d.toString()).slice(-2000); });
+    child.stderr.on('data', (d) => { stderrTail = (stderrTail + d.toString()).slice(-8000); });
     child.on('error', (e) => { hfChildren.delete(id); cleanup(); ws.send(JSON.stringify({ type: 'hfEvent', id, event: 'error', reason: 'spawn', detail: `${PYTHON_BIN}: ${e.message}` })); });
     child.on('close', (code) => {
       hfChildren.delete(id);
       cleanup();
-      if (!sawDone && code !== 0) ws.send(JSON.stringify({ type: 'hfEvent', id, event: 'error', reason: 'exit', detail: `python exited ${code}: ${stderrTail.slice(-300)}` }));
+      if (!sawDone && code !== 0) ws.send(JSON.stringify({ type: 'hfEvent', id, event: 'error', reason: 'exit', detail: `python exited ${code}: ${stderrTail}` }));
     });
   } catch (e) {
     cleanup();
@@ -242,6 +246,104 @@ async function handleHiggsfield(msg, ws) {
   }
 }
 
+// Pull the result video URL out of the CLI's `--json` output. The exact schema isn't publicly documented,
+// so scan defensively: each line (the CLI may print logs then a final JSON object), then known fields, then
+// any media URL. On a miss the caller returns the raw tail in the error so we can lock the field fast.
+function extractCliVideoUrl(out) {
+  const fromObj = (o) => {
+    if (!o || typeof o !== 'object') return null;
+    if (Array.isArray(o)) { for (const r of o) { const u = fromObj(r); if (u) return u; } return null; } // `generate create --json` returns [{ result_url }, …]
+    for (const k of ['result_url', 'output_url', 'video_url', 'url', 'resultUrl', 'outputUrl']) {
+      if (typeof o[k] === 'string' && /^https?:\/\//.test(o[k])) return o[k];
+    }
+    for (const arr of [o.results, o.outputs, o.assets]) {
+      if (Array.isArray(arr)) for (const r of arr) {
+        if (typeof r === 'string' && /^https?:\/\//.test(r)) return r;
+        const u = fromObj(r); if (u) return u;
+      }
+    }
+    return fromObj(o.result) || fromObj(o.job) || fromObj(o.data) || null;
+  };
+  const lines = out.split('\n').map((s) => s.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    try { const u = fromObj(JSON.parse(lines[i])); if (u) return u; } catch { /* not json */ }
+  }
+  try { const u = fromObj(JSON.parse(out)); if (u) return u; } catch { /* not one json blob */ }
+  const m = out.match(/https?:\/\/[^\s"']+\.(?:mp4|mov|webm|m4v)/i);
+  return m ? m[0] : null;
+}
+
+// Run a CREDIT-BILLED Seedance render via the official `higgsfield` CLI (separate from handleHiggsfield's CDP
+// path). The CLI blocks until done (--wait) and prints the result as JSON; we parse the URL and reply 'done'.
+async function handleHiggsfieldCli(msg, ws) {
+  const id = msg.id;
+  const p = msg.params || {};
+  const tmp = [];
+  const cleanup = () => { for (const f of tmp) unlink(f).catch(() => {}); };
+  try {
+    const images = Array.isArray(p.images) ? p.images : [];
+    for (let i = 0; i < images.length; i++) {
+      const f = join(tmpdir(), `sbhfcli_${id}_${i}.png`);
+      await writeFile(f, Buffer.from(String(images[i]), 'base64'));
+      tmp.push(f);
+    }
+    // Seedance multi-ref: upload each temp file → a medias[] array of role 'image', IN ORDER (= @imageN
+    // order). The single --start-image/--image flags map everything to one "start_image" and reject >1.
+    const runHf = (a) => new Promise((resolve, reject) => {
+      const child = spawn(HF_CLI, a, { shell: IS_WIN, stdio: ['ignore', 'pipe', 'pipe'] });
+      hfCliChildren.set(id, child);
+      let out = '', errTail = '';
+      child.stdout.on('data', (d) => { out += d.toString(); });
+      child.stderr.on('data', (d) => { errTail = (errTail + d.toString()).slice(-8000); });
+      child.on('error', (e) => reject(new Error(`${HF_CLI}: ${e.message}`)));
+      child.on('close', (code) => (code !== 0 ? reject(new Error(`higgsfield CLI exited ${code}: ${(errTail || out).slice(-8000)}`)) : resolve(out)));
+    });
+    const medias = [];
+    for (const f of tmp) {
+      const o = JSON.parse(await runHf(['upload', 'create', f, '--json']));
+      if (!o?.id) throw new Error('higgsfield upload returned no id');
+      medias.push({ role: 'image', data: { id: o.id, type: 'media_input' } }); // 'media_input' = uploaded file ('image' is rejected)
+    }
+    const promptStr = String(p.prompt ?? '');
+    const args = ['generate', 'create', String(p.slug || 'seedance_2_0'),
+      '--prompt', promptStr.startsWith('@') ? ' ' + promptStr : promptStr, // leading '@' = "read from file" to the CLI; a space neutralizes it
+      '--duration', String(Math.max(1, Math.round(p.durationSec || 5))),
+      '--resolution', String(p.resolution || '720p'),
+      '--aspect_ratio', String(p.aspectRatio || '16:9'),
+      '--json', '--wait'];
+    if (p.mode) args.push('--mode', String(p.mode));
+    if (medias.length) args.push('--medias', JSON.stringify(medias));
+    const out = await runHf(args);
+    hfCliChildren.delete(id);
+    cleanup();
+    const url = extractCliVideoUrl(out);
+    if (url) ws.send(JSON.stringify({ type: 'hfCliEvent', id, event: 'done', videoUrl: url }));
+    else ws.send(JSON.stringify({ type: 'hfCliEvent', id, event: 'error', reason: 'parse', detail: `no result URL in CLI output: ${out.slice(-8000)}` }));
+  } catch (e) {
+    hfCliChildren.delete(id);
+    cleanup();
+    ws.send(JSON.stringify({ type: 'hfCliEvent', id, event: 'error', reason: 'bridge', detail: String(e?.message ?? e) }));
+  }
+}
+
+// ---- disconnect-proof result delivery ----------------------------------------
+// claude -p runs independently of the socket, so a WS drop mid-job must NOT lose the answer. Job results go
+// through deliver(): sent on the live socket if open, else QUEUED in an outbox and flushed when we reconnect.
+// The backend keeps the job pending across the drop and resolves it by id on whichever socket the result
+// arrives on — so a deploy/network blip no longer turns a real answer into a mock fallback.
+let activeWs = null;
+const outbox = []; // JSON frame strings that couldn't be sent because the socket was down
+function deliver(frame) {
+  const s = JSON.stringify(frame);
+  if (activeWs && activeWs.readyState === 1 /* WebSocket.OPEN */) { try { activeWs.send(s); return; } catch { /* fall through → queue */ } }
+  outbox.push(s);
+}
+function flushOutbox() {
+  if (!activeWs || activeWs.readyState !== 1) return;
+  while (outbox.length) { try { activeWs.send(outbox.shift()); } catch { break; } }
+  if (outbox.length === 0) return;
+}
+
 // ---- connection (reconnects forever with backoff) ----
 let backoff = 1000;
 function connect() {
@@ -250,12 +352,15 @@ function connect() {
 
   ws.on('open', async () => {
     backoff = 1000;
+    activeWs = ws;       // this socket is now the delivery channel
+    flushOutbox();       // re-send any results that completed while we were disconnected
     const providers = {
       claude: await cliAvailable(BIN_FOR.claude),
       gemini: await cliAvailable(BIN_FOR.gemini),
     };
-    ws.send(JSON.stringify({ type: 'hello', version: VERSION, provider: PROVIDER, providers, files: !!FILES_ROOT, higgsfield: HIGGSFIELD }));
-    log(`connected to ${url} — serving jobs with: ${PROVIDER} (${BIN})${FILES_ROOT ? `; files → ${FILES_ROOT}` : ''}${HIGGSFIELD ? `; HIGGSFIELD HOST (python: ${PYTHON_BIN}, cdp: ${CDP_HTTP})` : ''}`);
+    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 }));
+    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.`);
     }
@@ -279,18 +384,18 @@ function connect() {
       const t0 = Date.now();
       try {
         const text = await runJob(String(msg.prompt ?? ''), Array.isArray(msg.images) ? msg.images : null);
-        ws.send(JSON.stringify({ type: 'result', id: msg.id, text }));
-        log(`job ${msg.id} ✓ (${Date.now() - t0}ms)`);
+        deliver({ type: 'result', id: msg.id, text }); // survives a mid-job reconnect (queued + flushed)
+        log(`job ${msg.id} ✓ (${Date.now() - t0}ms)${activeWs?.readyState === 1 ? '' : ' [queued — offline]'}`);
       } catch (e) {
-        ws.send(JSON.stringify({ type: 'error', id: msg.id, message: String(e?.message ?? e) }));
+        deliver({ type: 'error', id: msg.id, message: String(e?.message ?? e) });
         log(`job ${msg.id} ✗ ${e?.message ?? e}`);
       }
     } else if (msg.type === 'file' && msg.id) {
       try {
         const r = await handleFile(msg);
-        ws.send(JSON.stringify({ type: 'fileResult', id: msg.id, ...r }));
+        deliver({ type: 'fileResult', id: msg.id, ...r });
       } catch (e) {
-        ws.send(JSON.stringify({ type: 'fileError', id: msg.id, message: String(e?.message ?? e) }));
+        deliver({ type: 'fileError', id: msg.id, message: String(e?.message ?? e) });
         log(`file ${msg.op} ${msg.id} ✗ ${e?.message ?? e}`);
       }
     } else if (msg.type === 'higgsfield' && msg.id) {
@@ -300,11 +405,18 @@ function connect() {
       // user cancelled → stop this render so the single account slot frees (the python client honours SIGTERM)
       const child = hfChildren.get(msg.id);
       if (child) { log(`higgsfield ${msg.id} → cancel`); try { child.kill('SIGTERM'); } catch { /* already gone */ } hfChildren.delete(msg.id); }
+    } else if (msg.type === 'higgsfield-cli' && msg.id) {
+      log(`higgsfield-cli ${msg.id} → running`); handleHiggsfieldCli(msg, ws);
+    } else if (msg.type === 'higgsfield-cli-cancel' && msg.id) {
+      const child = hfCliChildren.get(msg.id);
+      if (child) { log(`higgsfield-cli ${msg.id} → cancel`); try { child.kill('SIGTERM'); } catch { /* already gone */ } hfCliChildren.delete(msg.id); }
     }
   });
 
   ws.on('close', () => {
-    log(`disconnected — retrying in ${Math.round(backoff / 1000)}s`);
+    if (activeWs === ws) activeWs = null; // stop sending on the dead socket; results queue until we reconnect
+    const queued = outbox.length ? ` (${outbox.length} result(s) queued for re-delivery)` : '';
+    log(`disconnected — retrying in ${Math.round(backoff / 1000)}s${queued}`);
     setTimeout(connect, backoff);
     backoff = Math.min(backoff * 2, 30000);
   });

package/package.json

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