storyforge 0.9.0 → 0.10.0

package/dist/{bridge-poller-DNGPP5MA.js → bridge-poller-G6LO7JFZ.js}

@@ -7330,11 +7330,18 @@ var BridgePoller = class {
     }
   }
   /**
-   * POST a rendered clip to /api/cli-bridge/upload-clip as multipart
-   * form data. The endpoint uploads the binary to Storj, inserts a
-   * `clips` table row, and returns the storj_key. Best-effort — a
-   * failed upload is recorded as a warning and the chunk's progress
-   * event reports phase='error' but doesn't take down the whole batch.
+   * Upload a rendered clip via signed-URL flow:
+   *   1. POST /api/cli-bridge/upload-url → { signedUrl, storjKey, version }
+   *   2. PUT file directly to Storj via signedUrl (bypasses Vercel —
+   *      lifts the body-size ceiling, MP4s of any size go through)
+   *   3. POST /api/cli-bridge/upload-finalize → inserts clips row,
+   *      regenerates manifest, returns { clipId }
+   *
+   * The legacy multipart path at /api/cli-bridge/upload-clip is still
+   * deployed for back-compat with storyforge < 0.10.0 in the wild,
+   * but new clients prefer this. Best-effort failure semantics —
+   * an upload error is logged + reported per-chunk but doesn't take
+   * down the whole render batch.
    */
   async uploadClipToStorj(bridgeJobId, projectId, spec, result) {
     try {
@@ -7343,30 +7350,63 @@ var BridgePoller = class {
       if (!stat.isFile() || stat.size === 0) {
         return { ok: false, error: `local clip empty or missing at ${result.outputPath}` };
       }
-      const buf = await fs16.readFile(result.outputPath);
       const durationFrames = Math.max(1, Math.round(result.durationSec * 30));
-      const form = new FormData();
-      form.append("bridgeJobId", bridgeJobId);
-      form.append("chunkId", result.chunkId);
-      form.append("engine", result.engine);
-      form.append("aspect", spec.aspect);
-      form.append("durationSec", String(result.durationSec));
-      form.append("durationFrames", String(durationFrames));
-      form.append("file", new Blob([new Uint8Array(buf)], { type: "video/mp4" }), `${result.chunkId}.mp4`);
-      const resp = await fetch(`${this.baseUrl}/api/cli-bridge/upload-clip`, {
+      const mintResp = await fetch(`${this.baseUrl}/api/cli-bridge/upload-url`, {
         method: "POST",
-        headers: { Authorization: `Bearer ${this.token}` },
-        body: form,
-        signal: AbortSignal.timeout(5 * 6e4)
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          bridgeJobId,
+          chunkId: result.chunkId,
+          aspect: spec.aspect,
+          contentType: "video/mp4"
+        }),
+        signal: AbortSignal.timeout(6e4)
       });
-      const text = await resp.text().catch(() => "");
-      if (!resp.ok) {
-        return { ok: false, error: `HTTP ${resp.status}: ${text.slice(0, 300)}` };
+      const mintText = await mintResp.text().catch(() => "");
+      if (!mintResp.ok) {
+        return { ok: false, error: `mint HTTP ${mintResp.status}: ${mintText.slice(0, 300)}` };
       }
-      const parsed = text ? JSON.parse(text) : {};
-      log.info(`[bridge] uploaded ${result.chunkId.slice(0, 8)} -> ${parsed.storjKey ?? "(no key)"}`);
+      const mint = JSON.parse(mintText);
+      const buf = await fs16.readFile(result.outputPath);
+      const putResp = await fetch(mint.signedUrl, {
+        method: "PUT",
+        headers: { "Content-Type": "video/mp4" },
+        body: new Uint8Array(buf),
+        signal: AbortSignal.timeout(15 * 6e4)
+      });
+      if (!putResp.ok) {
+        const putText = await putResp.text().catch(() => "");
+        return { ok: false, error: `storj PUT HTTP ${putResp.status}: ${putText.slice(0, 200)}` };
+      }
+      const finResp = await fetch(`${this.baseUrl}/api/cli-bridge/upload-finalize`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          bridgeJobId,
+          chunkId: result.chunkId,
+          aspect: spec.aspect,
+          version: mint.version,
+          storjKey: mint.storjKey,
+          engine: result.engine,
+          durationSec: result.durationSec,
+          durationFrames,
+          size: stat.size
+        }),
+        signal: AbortSignal.timeout(6e4)
+      });
+      const finText = await finResp.text().catch(() => "");
+      if (!finResp.ok) {
+        return { ok: false, storjKey: mint.storjKey, error: `finalize HTTP ${finResp.status}: ${finText.slice(0, 300)}` };
+      }
+      log.info(`[bridge] uploaded ${result.chunkId.slice(0, 8)} -> ${mint.storjKey} (v${mint.version}, ${(stat.size / 1024 / 1024).toFixed(1)}M)`);
       void projectId;
-      return { ok: true, storjKey: parsed.storjKey };
+      return { ok: true, storjKey: mint.storjKey };
     } catch (err) {
       return { ok: false, error: err.message };
     }

package/dist/index.js

@@ -547,7 +547,7 @@ var exec = promisify(execCb);
 var PORT = 4444;
 function runCliPipingStdin(cmd, args, stdinData, opts = {}) {
   const maxBytes = (opts.maxBufferMB ?? 16) * 1024 * 1024;
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const proc = spawn(cmd, args, { stdio: ["pipe", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -580,7 +580,7 @@ function runCliPipingStdin(cmd, args, stdinData, opts = {}) {
     });
     proc.on("close", (code) => {
       if (timer) clearTimeout(timer);
-      resolve5({ stdout, stderr, code });
+      resolve6({ stdout, stderr, code });
     });
     proc.stdin.end(stdinData);
   });
@@ -1501,9 +1501,9 @@ Return ONLY the complete updated TSX. No markdown fences, no explanation.`;
         }
         const boundary = boundaryM[1];
         const chunks = [];
-        await new Promise((resolve5, reject) => {
+        await new Promise((resolve6, reject) => {
           req.on("data", (c) => chunks.push(Buffer.from(c)));
-          req.on("end", resolve5);
+          req.on("end", resolve6);
           req.on("error", reject);
         });
         const body = Buffer.concat(chunks);
@@ -1615,7 +1615,7 @@ Return ONLY the complete updated TSX. No markdown fences, no explanation.`;
         return "0.0.0";
       })();
       void (async () => {
-        const { BridgePoller } = await import("./bridge-poller-DNGPP5MA.js");
+        const { BridgePoller } = await import("./bridge-poller-G6LO7JFZ.js");
         const poller = new BridgePoller({ baseUrl: bridgeUrl, token: bridgeToken, clientVersion: `storyforge ${pkgVersion}` });
         poller.start();
       })();
@@ -1640,10 +1640,10 @@ Return ONLY the complete updated TSX. No markdown fences, no explanation.`;
 import * as readline from "readline";
 function prompt(question) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve5(answer.trim());
+      resolve6(answer.trim());
     });
   });
 }
@@ -1765,7 +1765,7 @@ async function checkPython() {
   };
 }
 async function checkManim() {
-  const probe = await new Promise((resolve5) => {
+  const probe = await new Promise((resolve6) => {
     const p = spawn2("python3", ["-m", "manim", "--version"], { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -1775,18 +1775,18 @@ async function checkManim() {
     p.stderr.on("data", (d) => {
       stderr += d.toString("utf8");
     });
-    p.on("error", () => resolve5({ installed: false, version: null }));
+    p.on("error", () => resolve6({ installed: false, version: null }));
     p.on("close", (code) => {
       if (code === 0) {
         const m = (stdout + stderr).match(/Manim Community v(\S+)/);
-        resolve5({ installed: true, version: m?.[1] ?? null });
+        resolve6({ installed: true, version: m?.[1] ?? null });
       } else {
-        resolve5({ installed: false, version: null });
+        resolve6({ installed: false, version: null });
       }
     });
     setTimeout(() => {
       p.kill();
-      resolve5({ installed: false, version: null });
+      resolve6({ installed: false, version: null });
     }, 5e3);
   });
   return {
@@ -1915,11 +1915,11 @@ async function ask(rl, question) {
   return ans === "" || ans === "y" || ans === "yes";
 }
 function runStep(argv) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const [cmd, ...args] = argv;
     const proc = spawn3(cmd, args, { stdio: ["inherit", "inherit", "inherit"] });
-    proc.on("error", (err) => resolve5({ ok: false, tail: err.message }));
-    proc.on("close", (code) => resolve5({ ok: code === 0 }));
+    proc.on("error", (err) => resolve6({ ok: false, tail: err.message }));
+    proc.on("close", (code) => resolve6({ ok: code === 0 }));
   });
 }
 async function installRenderersCommand(opts = {}) {
@@ -2191,7 +2191,7 @@ async function ffmpegConcat(inputs, outPath) {
   const listBody = inputs.map((p) => `file '${p.replace(/'/g, "'\\''")}'`).join("\n") + "\n";
   fs5.writeFileSync(listPath, listBody);
   fs5.mkdirSync(path5.dirname(outPath), { recursive: true });
-  await new Promise((resolve5, reject) => {
+  await new Promise((resolve6, reject) => {
     const proc = spawn4("ffmpeg", [
       "-y",
       "-f",
@@ -2212,7 +2212,7 @@ async function ffmpegConcat(inputs, outPath) {
         fs5.rmSync(tmpDir, { recursive: true, force: true });
       } catch {
       }
-      if (code === 0) resolve5();
+      if (code === 0) resolve6();
       else reject(new Error(`ffmpeg exited ${code}`));
     });
   });
@@ -2293,23 +2293,58 @@ async function uploadClip(slug, diff, baseUrl, token) {
   const stat = await fs6.promises.stat(absPath);
   const durationSec = Math.max(1, Math.round(stat.size / 25e4));
   const durationFrames = durationSec * 30;
-  const form = new FormData();
-  form.append("chunkId", artifact.chunkId);
-  form.append("aspect", artifact.aspect ?? "16:9");
-  form.append("engine", "remotion");
-  form.append("durationSec", String(durationSec));
-  form.append("durationFrames", String(durationFrames));
-  form.append("file", new Blob([new Uint8Array(buf)], { type: "video/mp4" }), `${artifact.chunkId}.mp4`);
-  const resp = await fetch(`${baseUrl}/api/projects/${encodeURIComponent(slug)}/push-clip`, {
+  const aspect = artifact.aspect ?? "16:9";
+  const mint = await mintUploadUrl(slug, baseUrl, token, {
+    kind: "clips",
+    chunkId: artifact.chunkId,
+    aspect,
+    contentType: "video/mp4"
+  });
+  await putToStorj(mint.signedUrl, buf, "video/mp4");
+  const fin = await postFinalize(slug, baseUrl, token, {
+    kind: "clips",
+    storjKey: mint.storjKey,
+    chunkId: artifact.chunkId,
+    aspect,
+    version: mint.version,
+    engine: "remotion",
+    durationSec,
+    durationFrames
+  });
+  return { storjKey: mint.storjKey, clipId: fin.clipId, version: mint.version };
+}
+async function mintUploadUrl(slug, baseUrl, token, args) {
+  const resp = await fetch(`${baseUrl}/api/projects/${encodeURIComponent(slug)}/upload-url`, {
     method: "POST",
-    headers: { Authorization: `Bearer ${token}` },
-    body: form,
-    signal: AbortSignal.timeout(5 * 6e4)
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    body: JSON.stringify(args),
+    signal: AbortSignal.timeout(6e4)
   });
   const text = await resp.text().catch(() => "");
+  if (!resp.ok) throw new Error(`mint-url HTTP ${resp.status}: ${text.slice(0, 300)}`);
+  return JSON.parse(text);
+}
+async function putToStorj(signedUrl, body, contentType) {
+  const resp = await fetch(signedUrl, {
+    method: "PUT",
+    headers: { "Content-Type": contentType },
+    body: new Uint8Array(body),
+    signal: AbortSignal.timeout(15 * 6e4)
+  });
   if (!resp.ok) {
-    throw new Error(`HTTP ${resp.status}: ${text.slice(0, 300)}`);
+    const text = await resp.text().catch(() => "");
+    throw new Error(`storj PUT HTTP ${resp.status}: ${text.slice(0, 200)}`);
   }
+}
+async function postFinalize(slug, baseUrl, token, args) {
+  const resp = await fetch(`${baseUrl}/api/projects/${encodeURIComponent(slug)}/upload-finalize`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    body: JSON.stringify(args),
+    signal: AbortSignal.timeout(6e4)
+  });
+  const text = await resp.text().catch(() => "");
+  if (!resp.ok) throw new Error(`finalize HTTP ${resp.status}: ${text.slice(0, 300)}`);
   return JSON.parse(text);
 }
 function resolveBridgeToken(explicit) {
@@ -2326,13 +2361,82 @@ function humanBytes(n) {
 }
 async function confirm(prompt2) {
   const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve5) => rl.question(prompt2, resolve5));
+  const answer = await new Promise((resolve6) => rl.question(prompt2, resolve6));
   rl.close();
   return /^y(es)?$/i.test(answer.trim());
 }
 
+// src/commands/push-hook.ts
+import * as fs7 from "fs";
+import * as path7 from "path";
+var ALLOWED_EXTS = /* @__PURE__ */ new Set([".mp4", ".webm", ".mov"]);
+async function pushHookCommand(opts) {
+  const token = resolveBridgeToken2(opts.token);
+  if (!token) {
+    throw new Error(
+      "push-hook requires a bridge token. Run `storyforge login`, set BRIDGE_TOKEN, or pass --token <bearer>."
+    );
+  }
+  const baseUrl = resolveBaseUrl(opts.baseUrl);
+  if (opts.files.length === 0) throw new Error("no files to upload");
+  log.info(`push-hook \xB7 slug=${opts.slug}`);
+  log.info(`api    \xB7 ${baseUrl}`);
+  log.info(`files  \xB7 ${opts.files.length}`);
+  let succeeded = 0;
+  let failed = 0;
+  for (const filePath of opts.files) {
+    const absPath = path7.resolve(filePath);
+    if (!fs7.existsSync(absPath)) {
+      log.warn(`  \u2717 ${filePath} \u2014 not found`);
+      failed += 1;
+      continue;
+    }
+    const ext = path7.extname(absPath).toLowerCase();
+    if (!ALLOWED_EXTS.has(ext)) {
+      log.warn(`  \u2717 ${filePath} \u2014 unsupported extension ${ext}`);
+      failed += 1;
+      continue;
+    }
+    const filename = path7.basename(absPath);
+    const stat = fs7.statSync(absPath);
+    const sizeMB = (stat.size / 1024 / 1024).toFixed(1);
+    try {
+      const buf = fs7.readFileSync(absPath);
+      const contentType = ext === ".webm" ? "video/webm" : ext === ".mov" ? "video/quicktime" : "video/mp4";
+      const mint = await mintUploadUrl(opts.slug, baseUrl, token, {
+        kind: "hooks",
+        filename,
+        contentType
+      });
+      log.info(`  \u2191 ${filename} (${sizeMB}M) \u279C ${mint.storjKey}`);
+      await putToStorj(mint.signedUrl, buf, contentType);
+      await postFinalize(opts.slug, baseUrl, token, {
+        kind: "hooks",
+        storjKey: mint.storjKey,
+        filename
+      });
+      log.success(`    \u2713 uploaded`);
+      succeeded += 1;
+    } catch (err) {
+      log.warn(`    \u2717 ${err.message}`);
+      failed += 1;
+    }
+  }
+  log.info(`done \xB7 ${succeeded} uploaded \xB7 ${failed} failed`);
+  if (failed > 0 && succeeded === 0) {
+    throw new Error("all hooks failed to upload");
+  }
+}
+function resolveBridgeToken2(explicit) {
+  if (explicit) return explicit;
+  if (process.env.FORGE_BRIDGE_TOKEN) return process.env.FORGE_BRIDGE_TOKEN;
+  if (process.env.BRIDGE_TOKEN) return process.env.BRIDGE_TOKEN;
+  loadDotEnv();
+  return process.env.FORGE_BRIDGE_TOKEN ?? process.env.BRIDGE_TOKEN ?? null;
+}
+
 // src/index.ts
-var VERSION = "0.9.0";
+var VERSION = "0.10.0";
 var HELP = `
 storyforge \u2014 local bridge for the Forge video production web app
 
@@ -2340,6 +2444,8 @@ Usage:
   storyforge                       Auto-link current folder, start bridge, open browser (default)
   storyforge render <slug>         Pull a published project and render it locally to ./out.mp4
   storyforge push <slug>           Upload locally-edited clips back to Storj
+  storyforge push-hook <slug> <file> [<file>...]
+                                   Upload standalone hook MP4(s) to a project on Storj
   storyforge login                 Log in to forge.algo-thinker.com
   storyforge doctor                Probe local renderers (ffmpeg / python / manim / hyperframes)
   storyforge install-renderers     Install missing renderers (interactive, asks per-tool)
@@ -2415,6 +2521,31 @@ async function main() {
     await installRenderersCommand({ yes });
     return;
   }
+  if (firstArg === "push-hook") {
+    const slug = args[1];
+    if (!slug || slug.startsWith("--")) {
+      console.error("storyforge push-hook: missing slug. Usage: storyforge push-hook <slug> <file> [<file>...]");
+      process.exit(1);
+    }
+    const files = [];
+    let i = 2;
+    while (i < args.length && !args[i].startsWith("--")) {
+      files.push(args[i]);
+      i += 1;
+    }
+    if (files.length === 0) {
+      console.error("storyforge push-hook: no files supplied. Usage: storyforge push-hook <slug> <file> [<file>...]");
+      process.exit(1);
+    }
+    const opts2 = parseArgs(args.slice(i));
+    await pushHookCommand({
+      slug,
+      files,
+      baseUrl: typeof opts2["base-url"] === "string" ? opts2["base-url"] : void 0,
+      token: typeof opts2.token === "string" ? opts2.token : void 0
+    });
+    return;
+  }
   if (firstArg === "push") {
     const slug = args[1];
     if (!slug || slug.startsWith("--")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "storyforge",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "StoryForge — local bridge for the Forge video production web app. Parallel clip-render orchestrator (Remotion 4 + Manim + HyperFrames + ffmpeg) + final video stitcher + dependency doctor.",
   "type": "module",
   "bin": {