storyforge 0.7.4 → 0.8.0

package/dist/{bridge-poller-AMTSJVFB.js → bridge-poller-HA7G7ILD.js}

@@ -135,11 +135,11 @@ var require_p_limit = __commonJS({
 // src/bridge-poller.ts
 import { spawn as spawn2, spawnSync } from "child_process";
 import * as crypto from "crypto";
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 
 // ../pipeline/src/clip-render/render-chunk.ts
-import * as fs9 from "fs";
-import * as path10 from "path";
+import * as fs10 from "fs";
+import * as path11 from "path";
 
 // ../../node_modules/zod/v3/external.js
 var external_exports = {};
@@ -619,8 +619,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path11, errorMaps, issueData } = params;
-  const fullPath = [...path11, ...issueData.path || []];
+  const { data, path: path12, errorMaps, issueData } = params;
+  const fullPath = [...path12, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -736,11 +736,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path11, key) {
+  constructor(parent, value, path12, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path11;
+    this._path = path12;
     this._key = key;
   }
   get path() {
@@ -5345,7 +5345,8 @@ var ENGINE_FALLBACK_CHAIN = {
   hyperframes: "remotion",
   "stock+remotion": "remotion",
   manim: "remotion",
-  remotion: null
+  remotion: null,
+  "documentary-v2": "gemini+remotion"
 };
 function nextFallback(engine) {
   return ENGINE_FALLBACK_CHAIN[engine] ?? null;
@@ -6082,6 +6083,81 @@ var renderStockRemotion = async (shot, ctx) => {
   }
 };
 
+// ../pipeline/src/clip-render/engines/documentary-v2.ts
+import * as fs8 from "fs";
+import * as path9 from "path";
+var renderDocumentaryV2 = async (shot, ctx) => {
+  if (ctx.signal?.aborted) throw new Error("aborted");
+  if (!shot.prompt) {
+    throw new Error(
+      `documentary-v2: shot.prompt must be the path to a CompositionV2Data JSON file (shot ${shot.id})`
+    );
+  }
+  ctx.progress.emit({ phase: "preparing", shotId: shot.id });
+  let data;
+  if (shot.prompt.trimStart().startsWith("{")) {
+    data = JSON.parse(shot.prompt);
+  } else {
+    if (!fs8.existsSync(shot.prompt)) {
+      throw new Error(`documentary-v2: CompositionV2Data file not found: ${shot.prompt}`);
+    }
+    data = JSON.parse(fs8.readFileSync(shot.prompt, "utf8"));
+  }
+  const durationFrames = data.totalDurationFrames > 0 ? data.totalDurationFrames : Math.max(1, Math.round(shot.durationSec * ctx.fps));
+  const remotion = requireRemotionRoot();
+  const cacheRel = path9.posix.join("clip-render-cache", ctx.chunkId);
+  const cacheAbs = path9.join(remotion.cwd, "public", cacheRel);
+  fs8.mkdirSync(cacheAbs, { recursive: true });
+  for (const scene of data.scenes) {
+    for (const layer of scene.layers) {
+      if (!layer.assetPath) continue;
+      if (path9.isAbsolute(layer.assetPath) && fs8.existsSync(layer.assetPath)) {
+        const filename = path9.basename(layer.assetPath);
+        const destAbs = path9.join(cacheAbs, filename);
+        if (!fs8.existsSync(destAbs)) {
+          fs8.copyFileSync(layer.assetPath, destAbs);
+        }
+        layer.assetPath = path9.posix.join(cacheRel, filename);
+      }
+    }
+  }
+  const propsPath = path9.join(ctx.tmpDir, "remotion", `${shot.id}_dv2_props.json`);
+  fs8.mkdirSync(path9.dirname(propsPath), { recursive: true });
+  fs8.writeFileSync(propsPath, JSON.stringify({ compositionData: data }, null, 2));
+  ctx.progress.emit({
+    phase: "rendering",
+    shotId: shot.id,
+    framesRendered: 0,
+    totalFrames: durationFrames
+  });
+  const r = await runCmd(
+    "npx",
+    [
+      "remotion",
+      "render",
+      remotion.entry,
+      "DocumentaryV2",
+      "--props",
+      propsPath,
+      "--output",
+      ctx.sceneOutPath,
+      "--concurrency",
+      "4"
+    ],
+    { timeoutMs: 6e5, signal: ctx.signal, cwd: remotion.cwd }
+  );
+  if (r.code !== 0) {
+    const tail = r.stderr.split("\n").slice(-8).join(" ").slice(0, 400);
+    throw new Error(`documentary-v2 render failed (code ${r.code}): ${tail}`);
+  }
+  ctx.progress.emit({
+    phase: "rendering",
+    shotId: shot.id,
+    framesRendered: durationFrames,
+    totalFrames: durationFrames
+  });
+};
+
 // ../pipeline/src/clip-render/engines/index.ts
 var ENGINE_ADAPTERS = {
   "gemini+remotion": renderGeminiRemotion,
@@ -6091,7 +6167,8 @@ var ENGINE_ADAPTERS = {
   "remotion": renderRemotion,
   "stock+remotion": renderStockRemotion,
   "hyperframes": renderHyperframes,
-  "remotion+htmlcanvas": renderRemotionHtmlCanvas
+  "remotion+htmlcanvas": renderRemotionHtmlCanvas,
+  "documentary-v2": renderDocumentaryV2
 };
 var MANIM_ENGINES = /* @__PURE__ */ new Set([
   "manim",
@@ -6103,11 +6180,11 @@ function isManimEngine(engine) {
 }
 
 // ../pipeline/src/clip-render/fs-layout.ts
-import * as fs8 from "fs";
-import * as path9 from "path";
+import * as fs9 from "fs";
+import * as path10 from "path";
 function resolveProjectRoot(projectSlug, callerOutputDir) {
   if (callerOutputDir && callerOutputDir.length > 0) {
-    if (!path9.isAbsolute(callerOutputDir)) {
+    if (!path10.isAbsolute(callerOutputDir)) {
       throw new Error(
         `clip-render: spec.outputDir must be absolute, got "${callerOutputDir}"`
       );
@@ -6117,41 +6194,41 @@ function resolveProjectRoot(projectSlug, callerOutputDir) {
   if (!projectSlug || /[/\\]/.test(projectSlug)) {
     throw new Error(`clip-render: invalid projectSlug "${projectSlug}"`);
   }
-  return path9.resolve(process.cwd(), "forge-renders", projectSlug);
+  return path10.resolve(process.cwd(), "forge-renders", projectSlug);
 }
 function chunkPaths(projectSlug, chunkId, callerOutputDir) {
   if (!chunkId || /[/\\]/.test(chunkId)) {
     throw new Error(`clip-render: invalid chunkId "${chunkId}"`);
   }
   const root = resolveProjectRoot(projectSlug, callerOutputDir);
-  const tmpDir = path9.join(root, ".tmp", chunkId);
+  const tmpDir = path10.join(root, ".tmp", chunkId);
   return {
     root,
-    finalClipPath: path9.join(root, "clips", `${chunkId}.mp4`),
+    finalClipPath: path10.join(root, "clips", `${chunkId}.mp4`),
     tmpDir,
-    scenesDir: path9.join(tmpDir, "scenes"),
-    manimDir: path9.join(tmpDir, "manim"),
-    remotionDir: path9.join(tmpDir, "remotion"),
-    hyperframesDir: path9.join(tmpDir, "hyperframes"),
-    progressLogPath: path9.join(root, "progress.json")
+    scenesDir: path10.join(tmpDir, "scenes"),
+    manimDir: path10.join(tmpDir, "manim"),
+    remotionDir: path10.join(tmpDir, "remotion"),
+    hyperframesDir: path10.join(tmpDir, "hyperframes"),
+    progressLogPath: path10.join(root, "progress.json")
   };
 }
 function ensureChunkDirs(paths) {
   for (const dir of [
-    path9.dirname(paths.finalClipPath),
+    path10.dirname(paths.finalClipPath),
     paths.tmpDir,
     paths.scenesDir,
     paths.manimDir,
     paths.remotionDir,
     paths.hyperframesDir
   ]) {
-    fs8.mkdirSync(dir, { recursive: true });
+    fs9.mkdirSync(dir, { recursive: true });
   }
 }
 function appendProgress(progressLogPath, event) {
   try {
-    fs8.mkdirSync(path9.dirname(progressLogPath), { recursive: true });
-    fs8.appendFileSync(progressLogPath, JSON.stringify(event) + "\n");
+    fs9.mkdirSync(path10.dirname(progressLogPath), { recursive: true });
+    fs9.appendFileSync(progressLogPath, JSON.stringify(event) + "\n");
   } catch {
   }
 }
@@ -6254,10 +6331,10 @@ async function renderChunk(spec, opts = {}) {
       await renderWithEngine(spec, engine, paths, fps, tracker, opts);
       tracker.emit({ phase: "compositing", percent: 85 });
       const scenePaths = spec.shots.map((s) => sceneOutPath(paths, s));
-      const concatTarget = path10.join(paths.tmpDir, `${spec.chunkId}_video.mp4`);
+      const concatTarget = path11.join(paths.tmpDir, `${spec.chunkId}_video.mp4`);
       await concatScenes(scenePaths, concatTarget, { signal: opts.signal });
       if (opts.signal?.aborted) throw new Error("aborted");
-      const audioAvailable = !!spec.audioPath && fs9.existsSync(spec.audioPath);
+      const audioAvailable = !!spec.audioPath && fs10.existsSync(spec.audioPath);
       if (audioAvailable) {
         tracker.emit({ phase: "muxing", percent: 95 });
         await muxAudio(concatTarget, spec.audioPath, paths.finalClipPath, {
@@ -6269,7 +6346,7 @@ async function renderChunk(spec, opts = {}) {
         } else {
           warnings.push("no audioPath in spec \u2014 wrote silent clip");
         }
-        fs9.copyFileSync(concatTarget, paths.finalClipPath);
+        fs10.copyFileSync(concatTarget, paths.finalClipPath);
       }
       tracker.emit({ phase: "done", percent: 100 });
       const renderTimeMs2 = (opts.now ?? Date.now)() - startedAt;
@@ -6308,7 +6385,7 @@ async function renderChunk(spec, opts = {}) {
   };
 }
 function sceneOutPath(paths, shot) {
-  return path10.join(paths.scenesDir, `${shot.id}.mp4`);
+  return path11.join(paths.scenesDir, `${shot.id}.mp4`);
 }
 function abortedResult(spec, engine, fallbackDepth, startedAt, now) {
   return {
@@ -6341,7 +6418,7 @@ async function renderWithEngine(spec, engine, paths, fps, tracker, opts) {
       progress: tracker,
       resolvedEngine: engine
     };
-    fs9.mkdirSync(path10.dirname(ctx.sceneOutPath), { recursive: true });
+    fs10.mkdirSync(path11.dirname(ctx.sceneOutPath), { recursive: true });
     const release = opts.acquireManimSlot ? await opts.acquireManimSlot() : void 0;
     try {
       tracker.emit({
@@ -6353,7 +6430,7 @@ async function renderWithEngine(spec, engine, paths, fps, tracker, opts) {
     } finally {
       release?.();
     }
-    if (!fs9.existsSync(ctx.sceneOutPath)) {
+    if (!fs10.existsSync(ctx.sceneOutPath)) {
       throw new Error(
         `engine ${engine} produced no output at ${ctx.sceneOutPath} for shot ${shot.id}`
       );
@@ -6537,8 +6614,8 @@ var BridgePoller = class {
     if (!/^[a-z][a-z0-9-]*$/i.test(name)) return { available: false, path: null };
     const r = spawnSync("which", [name], { encoding: "utf-8", timeout: 2e3 });
     if (r.status !== 0) return { available: false, path: null };
-    const path11 = (r.stdout ?? "").trim();
-    return { available: !!path11, path: path11 || null };
+    const path12 = (r.stdout ?? "").trim();
+    return { available: !!path12, path: path12 || null };
   }
   async heartbeat() {
     if (this.stopped) return;
@@ -6759,13 +6836,36 @@ var BridgePoller = class {
         onProgress,
         signal: cancelController.signal
       });
+      const specByChunk = new Map(payload.specs.map((s) => [s.chunkId, s]));
+      const uploadOutcomes = [];
+      for (const r of result.results) {
+        if (!r.ok || !r.outputPath) continue;
+        const spec = specByChunk.get(r.chunkId);
+        if (!spec) continue;
+        const upload = await this.uploadClipToStorj(jobId, payload.projectId, spec, r);
+        uploadOutcomes.push({ chunkId: r.chunkId, ...upload });
+        void this.postRenderProgress(jobId, payload.projectId, {
+          chunkId: r.chunkId,
+          phase: upload.ok ? "done" : "error",
+          percent: upload.ok ? 100 : 95,
+          elapsedMs: r.renderTimeMs,
+          resolvedEngine: r.engine,
+          storjKey: upload.storjKey,
+          outputPath: r.outputPath,
+          error: upload.ok ? void 0 : `upload failed: ${upload.error ?? "unknown"}`,
+          ts: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
       const okCount = result.results.filter((r) => r.ok).length;
+      const uploadedCount = uploadOutcomes.filter((u) => u.ok).length;
       const summary = {
         kind: "render-clips",
-        ok: result.ok,
+        ok: result.ok && uploadedCount === okCount,
         total: result.results.length,
         succeeded: okCount,
         failed: result.results.length - okCount,
+        uploaded: uploadedCount,
+        uploadFailed: uploadOutcomes.filter((u) => !u.ok).length,
         totalRenderTimeMs: result.totalRenderTimeMs,
         observedPeakConcurrency: result.observedPeakConcurrency
       };
@@ -6776,6 +6876,48 @@ var BridgePoller = class {
       this.renderCancelControllers.delete(jobId);
     }
   }
+  /**
+   * 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.
+   */
+  async uploadClipToStorj(bridgeJobId, projectId, spec, result) {
+    try {
+      const fs12 = await import("fs/promises");
+      const stat = await fs12.stat(result.outputPath);
+      if (!stat.isFile() || stat.size === 0) {
+        return { ok: false, error: `local clip empty or missing at ${result.outputPath}` };
+      }
+      const buf = await fs12.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`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${this.token}` },
+        body: form,
+        signal: AbortSignal.timeout(5 * 6e4)
+      });
+      const text = await resp.text().catch(() => "");
+      if (!resp.ok) {
+        return { ok: false, error: `HTTP ${resp.status}: ${text.slice(0, 300)}` };
+      }
+      const parsed = text ? JSON.parse(text) : {};
+      log.info(`[bridge] uploaded ${result.chunkId.slice(0, 8)} -> ${parsed.storjKey ?? "(no key)"}`);
+      void projectId;
+      return { ok: true, storjKey: parsed.storjKey };
+    } catch (err) {
+      return { ok: false, error: err.message };
+    }
+  }
   /** POST a single RenderProgress event to /api/render-progress. */
   async postRenderProgress(bridgeJobId, projectId, event) {
     try {
@@ -6813,9 +6955,9 @@ var BridgePoller = class {
         error: `stitch-final job requires @forge/pipeline/stitch (not installed): ${err.message}`
       };
     }
-    const path11 = await import("path");
-    const projectRoot = path11.resolve(process.cwd(), "forge-renders", payload.projectSlug);
-    const clipsDir = path11.join(projectRoot, "clips");
+    const path12 = await import("path");
+    const projectRoot = path12.resolve(process.cwd(), "forge-renders", payload.projectSlug);
+    const clipsDir = path12.join(projectRoot, "clips");
     const publish = async (phase, eventPayload) => {
       try {
         await fetch(`${this.baseUrl}/api/cli-bridge/stitch-event`, {
@@ -6841,7 +6983,7 @@ var BridgePoller = class {
         projectSlug: payload.projectSlug,
         clipsDir,
         chunkOrder: payload.chunkOrder ?? [],
-        masterAudioPath: path11.isAbsolute(masterAudioRel) ? masterAudioRel : path11.join(projectRoot, masterAudioRel),
+        masterAudioPath: path12.isAbsolute(masterAudioRel) ? masterAudioRel : path12.join(projectRoot, masterAudioRel),
         outputDir: projectRoot,
         aspect: payload.aspect,
         skipTransitions: payload.skipTransitions,
@@ -7025,10 +7167,10 @@ function collectImagesFromCodexStdout(stdout, maxCount) {
   for (const p of paths) {
     if (images.length >= maxCount) break;
     try {
-      const stat = fs10.statSync(p);
+      const stat = fs11.statSync(p);
       if (!stat.isFile() || stat.size <= 0) continue;
       images.push({
-        base64: fs10.readFileSync(p).toString("base64"),
+        base64: fs11.readFileSync(p).toString("base64"),
         mimeType: mimeTypeForPath(p),
         model: "codex-cli:imagegen"
       });

package/dist/index.js

@@ -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-AMTSJVFB.js");
+        const { BridgePoller } = await import("./bridge-poller-HA7G7ILD.js");
         const poller = new BridgePoller({ baseUrl: bridgeUrl, token: bridgeToken, clientVersion: `storyforge ${pkgVersion}` });
         poller.start();
       })();
@@ -1992,7 +1992,7 @@ async function installRenderersCommand(opts = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.7.4";
+var VERSION = "0.7.5";
 var HELP = `
 storyforge \u2014 local bridge for the Forge video production web app
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "storyforge",
-  "version": "0.7.4",
+  "version": "0.8.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": {