@officexapp/vidfarm-devcli 0.21.55 → 0.21.57

package/dist/src/devcli/doctor.js

@@ -7,7 +7,7 @@
 // else prints as ⚠/✗ but does not fail the command, so agents can run doctor
 // unconditionally at session start.
 import { spawnSync } from "node:child_process";
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import net from "node:net";
 import { homedir } from "node:os";
@@ -143,6 +143,28 @@ export async function runDoctorCommand(argv) {
     const killOrphans = Boolean(parsed.values["kill-orphans"]);
     const checks = [];
     const add = (name, level, detail) => checks.push({ name, level, detail });
+    // 0. Are the two halves current, and are they the SAME version? The skill and
+    // the devcli ship on one semver, and a gap between them is the usual cause of
+    // "that command doesn't exist" — so it belongs in the health check, not only
+    // in the update runbook. Never fails the doctor: offline is not a defect, and
+    // a pending update is information, not breakage.
+    try {
+        const { installedDevcliVersion, installedSkillPath, readSkillVersion, compareSemver, readUpdateState, hoursSinceLastCheck } = await import("./update-check.js");
+        const devcli = installedDevcliVersion();
+        const skillPath = installedSkillPath();
+        const skill = skillPath ? readSkillVersion(readFileSync(skillPath, "utf8")) : null;
+        const since = hoursSinceLastCheck(readUpdateState());
+        const staleNote = since === null ? " · never checked for updates" : since >= 24 ? ` · last update check ${Math.round(since / 24)}d ago` : "";
+        if (devcli && skill && compareSemver(devcli, skill) !== 0) {
+            add("versions", "warn", `devcli ${devcli} vs skill ${skill} — MISMATCHED. They ship together; run: vidfarm update-check`);
+        }
+        else {
+            add("versions", since !== null && since < 24 ? "ok" : "warn", `devcli ${devcli ?? "?"} · skill ${skill ?? "not installed"}${staleNote}${staleNote ? " — vidfarm update-check" : ""}`);
+        }
+    }
+    catch {
+        // A version probe must never take the doctor down with it.
+    }
     // 1. Node version.
     const nodeMajor = Number(process.versions.node.split(".")[0]);
     add("node", nodeMajor >= 22 ? "ok" : "fail", `v${process.versions.node}${nodeMajor >= 22 ? "" : " — vidfarm-devcli needs Node >= 22"}`);

package/dist/src/devcli/local-frontend-server.js

@@ -560,7 +560,7 @@ async function startLocalRender(input) {
     void (async () => {
         try {
             const { renderCompositionLocally } = await import("./local-render.js");
-            await renderCompositionLocally({
+            const outcome = await renderCompositionLocally({
                 compositionHtml: compositionHtml,
                 outputPath,
                 stdio: "capture"
@@ -569,6 +569,11 @@ async function startLocalRender(input) {
             record.outputPath = outputPath;
             record.endedAt = Date.now();
             console.log(`[vidfarm] local render ${renderId} finished (${((record.endedAt - record.startedAt) / 1000).toFixed(1)}s) → ${outputPath}`);
+            // The editor keeps the file (a still card is a legal output here), but a
+            // frozen render is almost always a bug and must not pass silently.
+            if (outcome.motion?.frozen) {
+                console.warn(`[vidfarm] ⚠ render ${renderId} NEVER MOVES — ${outcome.motion.reason} Check for window.__player/__hf assignments and a registered window.__timelines entry (vidfarm lint).`);
+            }
         }
         catch (error) {
             record.status = "FAILED";
@@ -638,7 +643,7 @@ async function startStudioRender(input) {
     void (async () => {
         try {
             const { renderCompositionLocally } = await import("./local-render.js");
-            await renderCompositionLocally({
+            const outcome = await renderCompositionLocally({
                 compositionHtml,
                 outputPath,
                 fps,
@@ -650,6 +655,9 @@ async function startStudioRender(input) {
                         job.stage = "rendering";
                 }
             });
+            if (outcome.motion?.frozen) {
+                console.warn(`[vidfarm] ⚠ studio render ${job.filename} NEVER MOVES — ${outcome.motion.reason} Check for window.__player/__hf assignments and a registered window.__timelines entry (vidfarm lint).`);
+            }
             // A cancel marks the job terminal for the UI but cannot abort the child
             // process — don't resurrect a cancelled job when it eventually finishes.
             if (job.status === "rendering") {

package/dist/src/devcli/local-render.js

@@ -20,6 +20,8 @@ import os from "node:os";
 import path from "node:path";
 import { prepareProjectMediaForRender } from "../lib/render-media-prep.js";
 import { resolveBundledFfprobe } from "../lib/ffprobe-path.js";
+import { describeEngineGlobalHits, findEngineOwnedGlobalAssignments } from "../lib/engine-globals.js";
+import { checkRenderMotion } from "../lib/frozen-render.js";
 import { runHyperframesCommand } from "./hyperframes-cli.js";
 import { normalizeTikTokCaptionLayout } from "./composition-edit.js";
 // Same invariant as the backend's forceEvenCompositionDimensions: libx264
@@ -70,6 +72,16 @@ export async function renderCompositionLocally(input) {
     if (!input.compositionHtml.includes("data-composition-id=")) {
         throw new Error("Local render requires composition HTML with data-composition-id.");
     }
+    // ── Preflight: engine-owned globals ─────────────────────────────────────────
+    // Refuse BEFORE spending 45 seconds producing a still image. This is the one
+    // authoring mistake whose render "succeeds" in every observable way, so the
+    // only place it can be stopped is here.
+    if (!input.allowEngineGlobals) {
+        const hits = findEngineOwnedGlobalAssignments(input.compositionHtml);
+        if (hits.length > 0) {
+            throw new Error(`Refusing to render: ${describeEngineGlobalHits(hits)}`);
+        }
+    }
     const startedAt = Date.now();
     const projectDir = await mkdtemp(path.join(os.tmpdir(), "vidfarm-local-render-"));
     let prepNotes = [];
@@ -121,13 +133,27 @@ export async function renderCompositionLocally(input) {
         if (!existsSync(input.outputPath)) {
             throw new Error(`hyperframes render reported success but wrote no file at ${input.outputPath}`);
         }
+        // ── Post-render: does it actually move? ──────────────────────────────────
+        // hyperframes downgrades `sub_timeline_readiness_timeout` to a warning and
+        // writes the file anyway, so a correct-looking exit 0 is not evidence of a
+        // video. One cheap ffmpeg pass settles it. Never throws — a missing ffmpeg
+        // comes back `skipped` rather than failing a render that is probably fine.
+        let motion;
+        if (!input.skipMotionCheck) {
+            motion = await checkRenderMotion(input.outputPath);
+            if (motion.frozen)
+                log("local_render.frozen", { output: input.outputPath, ...motion });
+            else if (motion.skipped)
+                log("local_render.motion_unverified", { reason: motion.reason });
+        }
         const durationMs = Date.now() - startedAt;
-        log("local_render.succeeded", { output: input.outputPath, duration_ms: durationMs });
+        log("local_render.succeeded", { output: input.outputPath, duration_ms: durationMs, frozen: motion?.frozen ?? null });
         return {
             outputPath: input.outputPath,
             projectDir: input.keepProjectDir ? projectDir : null,
             durationMs,
-            prepNotes
+            prepNotes,
+            ...(motion ? { motion } : {})
         };
     }
     finally {