storyboard-bridge 0.3.8 → 0.5.0

package/index.mjs

@@ -73,7 +73,7 @@ const HF_SCRIPT = join(dirname(fileURLToPath(import.meta.url)), 'higgsfield_clie
 // prints raw text, and passing the flag makes it dump --help. Newer gemini supports it (wraps as
 // {response}) — opt in with GEMINI_JSON=1. extractText() handles wrapped OR raw either way.
 const USE_JSON = PROVIDER === 'claude' || process.env.GEMINI_JSON === '1';
-const JOB_TIMEOUT_MS = 300_000;
+const JOB_TIMEOUT_MS = 900_000; // 15 min — kills a `claude -p` that runs this long (SIGTERM → "exited null")
 
 const log = (m) => console.log(`[bridge ${new Date().toISOString().slice(11, 19)}] ${m}`);
 
@@ -102,13 +102,25 @@ function runCli(bin, args, stdinInput, cwd) {
   return new Promise((resolve, reject) => {
     // On Windows the CLI is usually a `.cmd` shim (claude.cmd) that spawn() can't launch without a
     // shell; shell:true uses PATHEXT to resolve it. POSIX (Linux/WSL/macOS) spawns the binary directly.
+    const t0 = Date.now();
     const child = spawn(bin, args, { timeout: JOB_TIMEOUT_MS, shell: IS_WIN, cwd });
     let out = '';
     let err = '';
     child.stdout.on('data', (d) => (out += d));
     child.stderr.on('data', (d) => (err += d));
-    child.on('error', reject);
-    child.on('close', (code) => (code === 0 ? resolve(out) : reject(new Error(`${bin} exited ${code}: ${err.slice(0, 300)}`))));
+    // heartbeat: proves the job is alive and shows whether it's PRODUCING output or truly hung (stdout stuck at 0)
+    const hb = setInterval(() => log(`  … ${bin} still running ${((Date.now() - t0) / 1000).toFixed(0)}s (stdout ${out.length}b, stderr ${err.length}b)`), 30_000);
+    child.on('error', (e) => { clearInterval(hb); reject(e); });
+    child.on('close', (code, signal) => {
+      clearInterval(hb);
+      const secs = ((Date.now() - t0) / 1000).toFixed(1);
+      if (code === 0) return resolve(out);
+      // code===null → killed by a SIGNAL (not a clean error). SIGTERM here = our JOB_TIMEOUT_MS hit; else OS/OOM.
+      const how = signal
+        ? `killed by ${signal}${signal === 'SIGTERM' ? ` — hit the ${JOB_TIMEOUT_MS / 1000}s job timeout (it was HANGING, not producing)` : ' (external kill — likely OS/out-of-memory)'}`
+        : `exited ${code}`;
+      reject(new Error(`${bin} ${how} after ${secs}s — produced ${out.length}b stdout; stderr: ${err.slice(0, 800).trim() || '(empty — nothing printed)'}`));
+    });
     // Feed the prompt via STDIN (not argv) — see runJob for why this matters on Windows.
     if (stdinInput != null) child.stdin.write(stdinInput);
     child.stdin.end();
@@ -281,14 +293,19 @@ async function handleHiggsfieldCli(msg, ws) {
   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.
+    // write the shipped bytes to temp files; the CLI AUTO-UPLOADS local paths given to its media flags,
+    // so we pass --image/--video directly (no manual `upload create`/--medias). Videos cap at 3 (Seedance).
+    const writeTmp = async (arr, ext) => {
+      const out = [];
+      for (let i = 0; i < arr.length; i++) {
+        const f = join(tmpdir(), `sbhfcli_${id}_${ext}${i}.${ext}`);
+        await writeFile(f, Buffer.from(String(arr[i]), 'base64'));
+        tmp.push(f); out.push(f);
+      }
+      return out;
+    };
+    const imageFiles = await writeTmp(Array.isArray(p.images) ? p.images : [], 'png');
+    const videoFiles = await writeTmp((Array.isArray(p.videos) ? p.videos : []).slice(0, 3), 'mp4');
     const runHf = (a) => new Promise((resolve, reject) => {
       const child = spawn(HF_CLI, a, { shell: IS_WIN, stdio: ['ignore', 'pipe', 'pipe'] });
       hfCliChildren.set(id, child);
@@ -298,20 +315,16 @@ async function handleHiggsfieldCli(msg, ws) {
       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', String(p.prompt ?? ''),
+      '--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));
+    for (const f of imageFiles) args.push('--image', f);
+    for (const f of videoFiles) args.push('--video', f);
     const out = await runHf(args);
     hfCliChildren.delete(id);
     cleanup();
@@ -325,6 +338,24 @@ async function handleHiggsfieldCli(msg, ws) {
   }
 }
 
+// ---- 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() {
@@ -333,6 +364,8 @@ 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),
@@ -361,20 +394,23 @@ function connect() {
       }
     } else if (msg.type === 'job' && msg.id) {
       const t0 = Date.now();
+      const promptLen = String(msg.prompt ?? '').length;
+      const imgCount = Array.isArray(msg.images) ? msg.images.length : 0;
+      log(`job ${msg.id} → running (prompt ${(promptLen / 1000).toFixed(1)}k chars${imgCount ? `, ${imgCount} image${imgCount === 1 ? '' : 's'}` : ''})`);
       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) {
@@ -393,7 +429,9 @@ function connect() {
   });
 
   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.8",
+  "version": "0.5.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": {