@lightcone-ai/daemon 0.15.76 → 0.15.77

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.15.76",
+  "version": "0.15.77",
   "type": "module",
   "main": "src/index.js",
   "bin": {

package/src/_vendor/video/composer-v2/index.js

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
 import path from 'node:path';
-import { mkdir, rm, writeFile, access } from 'node:fs/promises';
+import { mkdir, rm, writeFile, access, stat as statAsync } from 'node:fs/promises';
 import { constants as fsConstants } from 'node:fs';
 import os from 'node:os';
 import { randomUUID } from 'node:crypto';
@@ -407,7 +407,18 @@ export async function composeVideoV2({
     }
 
     const totalDuration = await probeDurationSec(outPath);
-    return { path: outPath, duration_ms: Math.round(totalDuration * 1000) };
+
+    // Stat the final file before returning so the caller can rely on size and
+    // so we can detect the (rare but observed) case where ffmpeg's `close`
+    // arrived but the kernel writeback wasn't complete. A 0-byte / tiny mp4
+    // here means the burn-subtitles pass produced nothing usable — fail loudly
+    // instead of letting a broken file flow into write_workspace_file / submit.
+    const finalStat = await statAsync(outPath);
+    const sizeBytes = Number(finalStat.size ?? 0);
+    if (!Number.isFinite(sizeBytes) || sizeBytes < 1024) {
+      throw new Error(`compose_video_v2 produced an invalid output: ${outPath} size=${sizeBytes} bytes`);
+    }
+    return { path: outPath, duration_ms: Math.round(totalDuration * 1000), size_bytes: sizeBytes };
   } finally {
     await rm(tmpDir, { recursive: true, force: true });
   }

package/src/tools/compose-video-v2.js

@@ -103,6 +103,7 @@ export async function runComposeVideoV2Tool({ segments, outro_paths, format, res
       'compose_video_v2 completed.',
       `path=${result.path}`,
       `duration_ms=${result.duration_ms}`,
+      `size_bytes=${result.size_bytes ?? 'unknown'}`,
       `segments=${segments.length}`,
       `outro_clips=${(outro_paths ?? []).length}`,
     ];

package/src/workspace-file-upload.js

@@ -1,7 +1,31 @@
 import path, { extname } from 'node:path';
-import { readFileSync, createReadStream } from 'node:fs';
+import { readFileSync, createReadStream, statSync } from 'node:fs';
 import { createHash } from 'node:crypto';
 
+// Wait for a file to stop growing before we read it. compose_video_v2 / ffmpeg
+// occasionally finishes the wrapping tool-call promise a fraction earlier than
+// the kernel finishes the last writeback for the output mp4 (observed: codex
+// reports item.completed at T, file mtime is T+60s, and write_workspace_file
+// reads a half-finished file in between). We stat → sleep → stat; if size or
+// mtime moved, the file is still being written and we retry. Cheap (200-400ms
+// for stable files; bounded retries for actively-growing ones).
+async function waitForFileStable(localPath, { intervalMs = 300, attempts = 10 } = {}) {
+  let lastSize = -1;
+  let lastMtime = -1;
+  for (let i = 0; i < attempts; i += 1) {
+    const st = statSync(localPath);
+    if (st.size === lastSize && st.mtimeMs === lastMtime) {
+      return { size: st.size };
+    }
+    lastSize = st.size;
+    lastMtime = st.mtimeMs;
+    await new Promise(r => setTimeout(r, intervalMs));
+  }
+  // Returned best-effort: caller can still proceed, but mismatch may surface
+  // at /storage/confirm size check.
+  return { size: lastSize };
+}
+
 export const WORKSPACE_BINARY_MIME = {
   '.mp4':  'video/mp4',
   '.png':  'image/png',
@@ -48,6 +72,11 @@ async function uploadBinaryFile({
   presign,   // async fn({ workspaceId, path, size, mime, sha256 }) → { uploadUrl, objectKey, alreadyExists }
   confirmUpload, // async fn({ workspaceId, path, objectKey }) → void
 }) {
+  // Wait until the source file is no longer being written. Without this we
+  // sometimes read a partial mp4 from a still-running ffmpeg, upload that
+  // partial buffer, and end up serving a truncated video downstream.
+  await waitForFileStable(localPath);
+
   const buf = readFileSync(localPath);
   const size = buf.length;
   const sha256 = sha256ofBuffer(buf);