@officexapp/vidfarm-devcli 0.21.10

package/dist/src/devcli/auth-store.js

@@ -0,0 +1,67 @@
+// Persisted devcli login. `vidfarm login` writes a small credential file to the
+// user's home so subsequent commands (and `vidfarm serve`) can point at cloud
+// prod without re-passing --api-key or exporting VIDFARM_API_KEY every shell.
+//
+// This lives in the CLI's static import closure and is BACKEND-FREE (only Node
+// built-ins), so it ships in the public cloud-only package. The file is written
+// 0600 (owner read/write) because it holds a live API key.
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+/** The durable per-user devcli home — mirrors local-backend's resolveLocalHome
+ *  so login state sits alongside the local data dir / provider config.json. */
+export function resolveDevcliHome(overrideDir) {
+    if (overrideDir)
+        return path.resolve(overrideDir);
+    if (process.env.VIDFARM_HOME)
+        return path.resolve(process.env.VIDFARM_HOME);
+    return path.join(homedir(), ".vidfarm");
+}
+function authFilePath(home) {
+    return path.join(resolveDevcliHome(home), "auth.json");
+}
+/** Read the persisted login, or null if absent/unparseable/incomplete. */
+export function readStoredAuth(home) {
+    try {
+        const parsed = JSON.parse(readFileSync(authFilePath(home), "utf8"));
+        if (parsed && typeof parsed.apiKey === "string" && typeof parsed.host === "string" && parsed.apiKey && parsed.host) {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Persist a login (0600). Returns the file path written. */
+export function writeStoredAuth(auth, home) {
+    const dir = resolveDevcliHome(home);
+    mkdirSync(dir, { recursive: true });
+    const file = authFilePath(home);
+    writeFileSync(file, `${JSON.stringify(auth, null, 2)}\n`, { mode: 0o600 });
+    // writeFileSync's mode only applies on create; force it in case the file
+    // pre-existed with looser perms.
+    try {
+        chmodSync(file, 0o600);
+    }
+    catch {
+        // Non-fatal (e.g. Windows) — the key is still stored.
+    }
+    return file;
+}
+/** Delete the persisted login. Returns true if a file was removed. */
+export function clearStoredAuth(home) {
+    const file = authFilePath(home);
+    if (!existsSync(file))
+        return false;
+    rmSync(file, { force: true });
+    return true;
+}
+/** True when two hosts refer to the same origin (trailing-slash/case-insensitive
+ *  and non-empty). Used to gate reuse of a stored key against a requested host so
+ *  a prod key is never sent to a different host. */
+export function hostsMatch(a, b) {
+    const norm = (h) => (h ?? "").replace(/\/+$/, "").trim().toLowerCase();
+    return norm(a).length > 0 && norm(a) === norm(b);
+}
+//# sourceMappingURL=auth-store.js.map

package/dist/src/devcli/captions.js

@@ -0,0 +1,310 @@
+// devcli `vidfarm captions …` — animated word-by-word captions (TikTok/CapCut
+// style) for a composition.html on disk. LOCAL-FIRST like `place`/`stt`: the
+// transcript comes from the user's own provider key (openai gives REAL
+// word-level timings via whisper-1; gemini/openrouter fall back to estimated
+// word windows), the DOM edit is a local file write, and a running
+// `vidfarm serve` live-morphs the change into open editor tabs. No cloud job,
+// no wallet. Feed it an --srt file (e.g. from `vidfarm stt --cloud`) to skip
+// STT entirely, or --text to page a script without any transcript.
+import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { parseArgs } from "node:util";
+import { clearCaptionLayers, computeCompositionGaps, inspectComposition, insertCaptionLayers, readCaptionCues, restyleCaptionLayers } from "./composition-edit.js";
+import { loadSpeechAudioLocally, localTranscribeSpeech, resolveLocalSpeechAuth, MAX_LOCAL_TRANSCRIBE_AUDIO_BYTES } from "./speech.js";
+import { buildCaptionCues, cuesFromText } from "../services/captions.js";
+import { CAPTION_ANIMATIONS, CAPTION_STYLE_PRESETS } from "../hyperframes/composition.js";
+export const CAPTIONS_HELP = `vidfarm captions — animated word-by-word captions (local STT + local file write)
+
+  captions generate <dir|composition.html>   Transcribe narration & lay down animated caption cues
+    --audio <file|url>        Audio/video to transcribe. Default: the composition's first
+                              audio layer src, else its first video layer src.
+    --srt <file>              Skip STT; build cues from this SRT subtitle file.
+    --text "<script>"         Skip STT; page this text across [--start, --start+--duration].
+    --style <preset>          ${CAPTION_STYLE_PRESETS.map((p) => p.id).join(" | ")}   (default: spotlight)
+    --animation <anim>        ${CAPTION_ANIMATIONS.join(" | ")}
+    --active-color <css>      Color the active word takes while spoken
+    --highlight-color <css>   Pill behind the active word (highlight-pop)
+    --color / --background / --background-style plain|outline|highlight-solid|highlight-translucent
+    --font <family> / --font-size <px> / --uppercase
+    --max-words <n>           Words per cue page (default 4)
+    --track <n> / --x / --y / --width / --height (%)
+    --provider <p>            openai | gemini | openrouter (default: openai first — it has
+                              real word timestamps; gemini/openrouter estimate word windows)
+    --language <code>         Expected audio language
+    --offset <sec>            Shift every cue (e.g. narration layer's start)
+    --start <sec> --duration <sec>   Window for --text paging
+    --json
+
+  captions style <dir|composition.html> --style <preset>   Restyle existing cues (same text/timing)
+  captions list  <dir|composition.html> [--json]           Show current animated caption cues
+  captions clear <dir|composition.html>                    Remove all animated caption layers
+
+Word timings ride inside each cue layer (per-word animation-delay/duration), so preview,
+serve live-morph, local render, and cloud render all animate identically. \`publish\` pushes
+the edited composition to the cloud as usual.
+`;
+const STYLE_FLAG_OPTIONS = {
+    style: { type: "string" },
+    animation: { type: "string" },
+    "active-color": { type: "string" },
+    "highlight-color": { type: "string" },
+    color: { type: "string" },
+    background: { type: "string" },
+    "background-style": { type: "string" },
+    font: { type: "string" },
+    "font-size": { type: "string" },
+    uppercase: { type: "boolean" },
+    track: { type: "string" },
+    x: { type: "string" },
+    y: { type: "string" },
+    width: { type: "string" },
+    height: { type: "string" }
+};
+export async function runCaptionsCommand(argv) {
+    const sub = argv[0];
+    const rest = argv.slice(1);
+    switch (sub) {
+        case "generate":
+            return runGenerate(rest);
+        case "style":
+            return runStyle(rest);
+        case "list":
+            return runListCues(rest);
+        case "clear":
+            return runClear(rest);
+        case undefined:
+        case "help":
+        case "--help":
+        case "-h":
+            console.log(CAPTIONS_HELP);
+            return;
+        default:
+            console.error(`Unknown captions subcommand: ${sub}\n`);
+            console.log(CAPTIONS_HELP);
+            process.exitCode = 1;
+    }
+}
+// Same dir-or-file resolution as `vidfarm place` (cli.ts resolveCompositionHtmlPath).
+function resolveCompositionHtml(target) {
+    if (!target)
+        throw new Error("Provide the composition dir or composition.html path.");
+    const abs = path.resolve(process.cwd(), target);
+    if (existsSync(abs) && statSync(abs).isDirectory()) {
+        const inside = path.join(abs, "composition.html");
+        if (!existsSync(inside))
+            throw new Error(`No composition.html inside ${abs}. Run \`vidfarm pull <forkId> --dir ${target}\` first.`);
+        return inside;
+    }
+    if (!existsSync(abs))
+        throw new Error(`No such composition file or dir: ${abs}.`);
+    return abs;
+}
+function styleOptionsFromFlags(values) {
+    const num = (key) => {
+        const raw = values[key];
+        if (typeof raw !== "string" || !raw.trim())
+            return undefined;
+        const parsed = Number(raw);
+        if (!Number.isFinite(parsed))
+            throw new Error(`--${key} must be a number.`);
+        return parsed;
+    };
+    return {
+        style: typeof values.style === "string" ? values.style : undefined,
+        animation: typeof values.animation === "string" ? values.animation : undefined,
+        activeColor: typeof values["active-color"] === "string" ? values["active-color"] : undefined,
+        highlightColor: typeof values["highlight-color"] === "string" ? values["highlight-color"] : undefined,
+        uppercase: values.uppercase === true ? true : undefined,
+        color: typeof values.color === "string" ? values.color : undefined,
+        background: typeof values.background === "string" ? values.background : undefined,
+        backgroundStyle: typeof values["background-style"] === "string" ? values["background-style"] : undefined,
+        fontFamily: typeof values.font === "string" ? values.font : undefined,
+        fontSize: num("font-size"),
+        track: num("track"),
+        x: num("x"),
+        y: num("y"),
+        width: num("width"),
+        height: num("height")
+    };
+}
+// Minimal SRT reader: index / "start --> end" / text lines. Produces the same
+// segment shape STT returns so cue building is one code path.
+export function parseSrtToSegments(srt) {
+    const toSeconds = (stamp) => {
+        const match = /(\d+):(\d+):(\d+)[,.](\d+)/.exec(stamp.trim());
+        if (!match)
+            return null;
+        return Number(match[1]) * 3600 + Number(match[2]) * 60 + Number(match[3]) + Number(match[4].padEnd(3, "0").slice(0, 3)) / 1000;
+    };
+    const segments = [];
+    for (const block of srt.split(/\r?\n\r?\n+/)) {
+        const lines = block.split(/\r?\n/).filter((line) => line.trim());
+        const timingIndex = lines.findIndex((line) => line.includes("-->"));
+        if (timingIndex === -1)
+            continue;
+        const [startRaw, endRaw] = lines[timingIndex].split("-->");
+        const start = toSeconds(startRaw ?? "");
+        const end = toSeconds(endRaw ?? "");
+        const text = lines.slice(timingIndex + 1).join(" ").replace(/<[^>]+>/g, "").trim();
+        if (start === null || !text)
+            continue;
+        segments.push({ speaker: "speaker_1", start_sec: start, end_sec: end, text });
+    }
+    return segments;
+}
+// Default transcription source: the composition's own narration. Prefer a
+// dedicated audio layer; fall back to the first video layer with a src.
+function defaultAudioSource(htmlPath, html) {
+    const info = inspectComposition(html);
+    const candidate = info.layers.find((layer) => layer.kind === "audio" && layer.src)
+        ?? info.layers.find((layer) => layer.kind === "video" && layer.src);
+    if (!candidate?.src)
+        return null;
+    const src = candidate.src;
+    if (/^https?:\/\//i.test(src))
+        return src;
+    // Relative srcs resolve against the composition dir (pull/serve layouts).
+    return path.resolve(path.dirname(htmlPath), src.replace(/^\.\//, ""));
+}
+async function runGenerate(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            ...STYLE_FLAG_OPTIONS,
+            audio: { type: "string" },
+            srt: { type: "string" },
+            text: { type: "string" },
+            "max-words": { type: "string" },
+            provider: { type: "string" },
+            language: { type: "string" },
+            offset: { type: "string" },
+            start: { type: "string" },
+            duration: { type: "string" },
+            "gemini-key": { type: "string" },
+            "openai-key": { type: "string" },
+            "openrouter-key": { type: "string" },
+            json: { type: "boolean" }
+        }
+    });
+    const htmlPath = resolveCompositionHtml(positionals[0]);
+    const html = readFileSync(htmlPath, "utf8");
+    const info = inspectComposition(html);
+    const maxWords = values["max-words"] ? Math.max(1, Math.round(Number(values["max-words"]))) : 4;
+    const offsetSec = values.offset ? Number(values.offset) : 0;
+    if (!Number.isFinite(offsetSec))
+        throw new Error("--offset must be a number of seconds.");
+    let cues;
+    let sourceNote;
+    if (typeof values.text === "string" && values.text.trim()) {
+        const start = values.start ? Number(values.start) : 0;
+        const duration = values.duration ? Number(values.duration) : Math.max(0.4, info.duration_seconds - start);
+        cues = cuesFromText(values.text, start + offsetSec, duration, { maxWordsPerCue: maxWords });
+        sourceNote = "provided text (estimated word timings)";
+    }
+    else if (typeof values.srt === "string" && values.srt.trim()) {
+        const srtPath = path.resolve(process.cwd(), values.srt);
+        if (!existsSync(srtPath))
+            throw new Error(`No such SRT file: ${srtPath}`);
+        const segments = parseSrtToSegments(readFileSync(srtPath, "utf8"));
+        if (!segments.length)
+            throw new Error(`No cues found in ${srtPath}.`);
+        cues = buildCaptionCues(segments, { maxWordsPerCue: maxWords, offsetSec, fallbackDurationSec: info.duration_seconds });
+        sourceNote = `${path.basename(srtPath)} (${segments.length} SRT cues, estimated word timings)`;
+    }
+    else {
+        // openai first: whisper-1 verbose_json is the only path with REAL word
+        // timestamps, which is what makes the word-by-word animation land on beat.
+        const auth = resolveLocalSpeechAuth(values, ["openai", "gemini", "openrouter"], typeof values.provider === "string" ? values.provider : undefined);
+        if (!auth) {
+            throw new Error("No local provider key found. Export OPENAI_API_KEY (best: real word timings), GEMINI_API_KEY, or OPENROUTER_API_KEY — or pass --srt/--text instead.");
+        }
+        const audioTarget = typeof values.audio === "string" && values.audio.trim()
+            ? values.audio.trim()
+            : defaultAudioSource(htmlPath, html);
+        if (!audioTarget) {
+            throw new Error("Could not find narration to transcribe (no audio/video layer with a src). Pass --audio <file|url>, --srt, or --text.");
+        }
+        console.log(`Transcribing ${audioTarget} (${auth.provider}, local key)…`);
+        const audio = await loadSpeechAudioLocally(audioTarget);
+        if (audio.bytes.byteLength > MAX_LOCAL_TRANSCRIBE_AUDIO_BYTES) {
+            throw new Error(`Audio is ${(audio.bytes.byteLength / (1024 * 1024)).toFixed(1)}MB (limit ${(MAX_LOCAL_TRANSCRIBE_AUDIO_BYTES / (1024 * 1024)).toFixed(0)}MB). Trim it or transcribe externally and pass --srt.`);
+        }
+        const transcript = await localTranscribeSpeech({
+            auth,
+            audio: audio.bytes,
+            contentType: audio.contentType,
+            language: typeof values.language === "string" ? values.language : undefined,
+            diarize: auth.provider === "gemini",
+            wordTimestamps: true
+        });
+        if (!transcript.segments.length)
+            throw new Error("Transcription returned no speech segments.");
+        cues = buildCaptionCues(transcript.segments, { maxWordsPerCue: maxWords, offsetSec, fallbackDurationSec: info.duration_seconds });
+        const hasRealWords = transcript.segments.some((segment) => segment.words?.length);
+        sourceNote = `${transcript.provider}/${transcript.model} (${hasRealWords ? "word-level timestamps" : "estimated word timings"})`;
+    }
+    if (!cues.length)
+        throw new Error("No caption cues produced.");
+    // Keep cues inside the composition's duration.
+    cues = cues.filter((cue) => cue.start < info.duration_seconds)
+        .map((cue) => ({ ...cue, duration: Math.min(cue.duration, Math.max(0.1, info.duration_seconds - cue.start)) }));
+    const result = insertCaptionLayers(html, cues, styleOptionsFromFlags(values));
+    writeFileSync(htmlPath, result.html);
+    if (values.json) {
+        console.log(JSON.stringify({ ok: true, style: result.styleId, cues: cues.length, replaced: result.replaced, layer_keys: result.layerKeys, source: sourceNote, gaps: computeCompositionGaps(result.html) }, null, 2));
+        return;
+    }
+    console.log(`Wrote ${cues.length} animated caption cues (style: ${result.styleId}) from ${sourceNote}.`);
+    if (result.replaced > 0)
+        console.log(`Replaced ${result.replaced} previous caption cues.`);
+    console.log(`Updated ${htmlPath} — a running \`vidfarm serve\` live-morphs it; \`vidfarm publish\` pushes to cloud.`);
+}
+async function runStyle(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: { ...STYLE_FLAG_OPTIONS, json: { type: "boolean" } }
+    });
+    const htmlPath = resolveCompositionHtml(positionals[0]);
+    const opts = styleOptionsFromFlags(values);
+    if (!opts.style && !opts.animation && !opts.activeColor && !opts.highlightColor && opts.uppercase === undefined && !opts.color && !opts.background && !opts.backgroundStyle && !opts.fontFamily && opts.fontSize === undefined) {
+        throw new Error("captions style needs at least one style flag (e.g. --style karaoke).");
+    }
+    const result = restyleCaptionLayers(readFileSync(htmlPath, "utf8"), opts);
+    writeFileSync(htmlPath, result.html);
+    if (values.json) {
+        console.log(JSON.stringify({ ok: true, style: result.styleId, cues: result.layerKeys.length }, null, 2));
+        return;
+    }
+    console.log(`Restyled ${result.layerKeys.length} caption cues to ${result.styleId}.`);
+}
+async function runListCues(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: { json: { type: "boolean" } }
+    });
+    const htmlPath = resolveCompositionHtml(positionals[0]);
+    const cues = readCaptionCues(readFileSync(htmlPath, "utf8"));
+    if (values.json) {
+        console.log(JSON.stringify({ cues }, null, 2));
+        return;
+    }
+    if (!cues.length) {
+        console.log("No animated caption layers. Run `vidfarm captions generate <dir>` to add some.");
+        return;
+    }
+    for (const cue of cues) {
+        console.log(`${cue.start.toFixed(2).padStart(8)}s +${cue.duration.toFixed(2)}s  ${cue.text}`);
+    }
+    console.log(`${cues.length} cues on track ${cues[0].track}.`);
+}
+async function runClear(argv) {
+    const { positionals } = parseArgs({ args: argv, allowPositionals: true, options: {} });
+    const htmlPath = resolveCompositionHtml(positionals[0]);
+    const result = clearCaptionLayers(readFileSync(htmlPath, "utf8"));
+    writeFileSync(htmlPath, result.html);
+    console.log(`Removed ${result.removed} animated caption layer${result.removed === 1 ? "" : "s"}.`);
+}
+//# sourceMappingURL=captions.js.map