@officexapp/vidfarm-devcli 0.21.10

package/dist/src/devcli/speech.js

@@ -0,0 +1,178 @@
+// Local speech engine — devcli-only. `vidfarm tts` / `vidfarm stt` run
+// LOCAL-FIRST on the user's own AI key (GEMINI_API_KEY / OPENAI_API_KEY /
+// OPENROUTER_API_KEY, or the --gemini-key/--openai-key/--openrouter-key flags)
+// by calling the shared speech provider layer (src/services/speech.ts)
+// directly: local ffmpeg for the video→audio demux, the user's key for the
+// model call — no cloud job, no wallet, no REST route. The REST primitive
+// routes (/api/v1/primitives/audio/speech|transcribe) are the explicit
+// `--cloud` BACKUP, mirroring `vidfarm clips scan`.
+//
+// Unlike clip tagging, speech can NOT ride on a claude/codex CLI agent — the
+// agent CLIs have no audio I/O (the same reason embeddings need a real key in
+// local-agent.ts) — so "local" here means a raw provider key, not the agent.
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { buildSrtFromSegments, defaultSpeechModelFor, generateSpeechWithKey, transcribeSpeechWithKey } from "../services/speech.js";
+import { resolveFfmpeg } from "../services/clip-curation/ffmpeg.js";
+// Mirrors the env-var fallbacks used by `vidfarm clips` so one exported key
+// powers every local-first devcli surface.
+const PROVIDER_ENV = {
+    gemini: ["GEMINI_API_KEY", "GOOGLE_GENERATIVE_AI_API_KEY"],
+    openai: ["OPENAI_API_KEY"],
+    openrouter: ["OPENROUTER_API_KEY"]
+};
+const PROVIDER_FLAG = {
+    gemini: "gemini-key",
+    openai: "openai-key",
+    openrouter: "openrouter-key"
+};
+// Same inline-audio ceiling as the cloud stt primitive (~40min of 64kbps mono).
+export const MAX_LOCAL_TRANSCRIBE_AUDIO_BYTES = 20 * 1024 * 1024;
+/**
+ * Find a usable local provider key: an explicit --provider narrows the search,
+ * otherwise the first provider (in `preference` order) with a flag/env key
+ * wins. Returns null when nothing local is configured (callers point the user
+ * at env keys or --cloud).
+ */
+export function resolveLocalSpeechAuth(values, preference, requestedProvider) {
+    const providers = requestedProvider
+        ? [normalizeSpeechProvider(requestedProvider)]
+        : preference;
+    for (const provider of providers) {
+        const flagged = values[PROVIDER_FLAG[provider]];
+        if (typeof flagged === "string" && flagged.trim()) {
+            return { provider, apiKey: flagged.trim() };
+        }
+        for (const envName of PROVIDER_ENV[provider]) {
+            const fromEnv = process.env[envName]?.trim();
+            if (fromEnv) {
+                return { provider, apiKey: fromEnv };
+            }
+        }
+    }
+    return null;
+}
+export function normalizeSpeechProvider(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "gemini" || normalized === "openai" || normalized === "openrouter") {
+        return normalized;
+    }
+    throw new Error(`Unsupported speech provider "${value}". Use gemini, openai, or openrouter.`);
+}
+/** Local TTS: text → audio bytes on the user's own key. */
+export async function localGenerateSpeech(input) {
+    const model = input.model?.trim() || defaultSpeechModelFor("tts", input.auth.provider);
+    if (!model) {
+        throw new Error(`No TTS model available for provider ${input.auth.provider}.`);
+    }
+    const result = await generateSpeechWithKey({
+        provider: input.auth.provider,
+        model,
+        text: input.text,
+        voice: input.voice,
+        instructions: input.instructions,
+        responseFormat: input.responseFormat,
+        apiKey: input.auth.apiKey
+    });
+    return { ...result, provider: input.auth.provider, model };
+}
+/** Local STT: audio bytes → transcript (diarized on gemini) on the user's own key.
+ * wordTimestamps requests word-level timings (real on openai/whisper-1; other
+ * providers stay segment-level and downstream callers estimate word windows). */
+export async function localTranscribeSpeech(input) {
+    const model = input.model?.trim() || defaultSpeechModelFor("stt", input.auth.provider);
+    if (!model) {
+        throw new Error(`No STT model available for provider ${input.auth.provider}.`);
+    }
+    const result = await transcribeSpeechWithKey({
+        provider: input.auth.provider,
+        model,
+        audio: input.audio,
+        contentType: input.contentType,
+        prompt: input.prompt,
+        language: input.language,
+        diarize: input.diarize,
+        wordTimestamps: input.wordTimestamps,
+        apiKey: input.auth.apiKey
+    });
+    return { ...result, provider: input.auth.provider, model, srt: buildSrtFromSegments(result.segments) };
+}
+const AUDIO_EXTENSION_CONTENT_TYPES = {
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    m4a: "audio/mp4",
+    aac: "audio/mp4",
+    ogg: "audio/ogg",
+    oga: "audio/ogg",
+    flac: "audio/flac"
+};
+function audioExtensionOf(target) {
+    const match = /\.(mp3|wav|m4a|aac|ogg|oga|flac)(\?|#|$)/i.exec(target);
+    return match ? match[1].toLowerCase() : null;
+}
+/**
+ * Turn a local path OR http(s) URL — video or audio — into speech-provider
+ * ready audio bytes. Plain audio files pass through untouched; everything else
+ * (video, unknown containers) is demuxed to small mono mp3 by LOCAL ffmpeg
+ * (bundled ffmpeg-static, or PATH), which reads URLs directly.
+ */
+export async function loadSpeechAudioLocally(target) {
+    const isUrl = /^https?:\/\//i.test(target);
+    if (!isUrl && !existsSync(target)) {
+        throw new Error(`No such local file: ${target}`);
+    }
+    const audioExtension = audioExtensionOf(target);
+    if (audioExtension) {
+        if (isUrl) {
+            const response = await fetch(target);
+            if (!response.ok) {
+                throw new Error(`Could not fetch source audio (${response.status}).`);
+            }
+            const contentType = response.headers.get("content-type")?.split(";")[0]?.trim() || AUDIO_EXTENSION_CONTENT_TYPES[audioExtension];
+            return { bytes: new Uint8Array(await response.arrayBuffer()), contentType, demuxed: false };
+        }
+        return { bytes: readFileSync(target), contentType: AUDIO_EXTENSION_CONTENT_TYPES[audioExtension], demuxed: false };
+    }
+    const ffmpeg = await resolveFfmpeg();
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "vidfarm-stt-"));
+    const outputPath = path.join(tempDir, "audio.mp3");
+    try {
+        await runFfmpegDemux(ffmpeg, target, outputPath);
+        return { bytes: await readFile(outputPath), contentType: "audio/mpeg", demuxed: true };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+function runFfmpegDemux(bin, input, outputPath) {
+    return new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn(bin, [
+            "-hide_banner",
+            "-y",
+            "-i", input,
+            "-vn",
+            "-ac", "1",
+            "-b:a", "64k",
+            outputPath
+        ], { stdio: ["ignore", "ignore", "pipe"] });
+        let stderr = "";
+        child.stderr.on("data", (chunk) => (stderr += chunk.toString()));
+        child.on("error", (error) => {
+            rejectPromise(error.code === "ENOENT"
+                ? new Error("ffmpeg not found. Install ffmpeg (or `npm i ffmpeg-static`), or run with --cloud to demux on the platform.")
+                : error);
+        });
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolvePromise();
+            }
+            else {
+                rejectPromise(new Error(`ffmpeg demux exited ${code}: ${stderr.slice(-400)}`));
+            }
+        });
+    });
+}
+//# sourceMappingURL=speech.js.map

package/dist/src/devcli/stills.js

@@ -0,0 +1,249 @@
+// `vidfarm stills` — render PNG still frames of the CURRENT composition
+// in-process, without a full MP4 render. This is the coding agent's visual
+// self-verification loop: edit composition.html, render 3-8 stills, look at
+// them, iterate.
+//
+// Implementation mirrors HyperframesService.renderStill (src/services/
+// hyperframes.ts): stage the composition as a HyperFrames project dir, drive
+// @hyperframes/producer's createRenderJob/executeRenderJob with the
+// "png-sequence" format, then pick the captured frames nearest each requested
+// timestamp. Deliberately NOT importing HyperframesService — that class drags
+// in config.ts (which mkdirs at import) and the whole cloud-render surface;
+// this is a lean local-file implementation.
+//
+// Cost control: png-sequence captures EVERY frame on the fps grid, so we
+// (a) cap the staged composition's duration at the last requested timestamp
+// and (b) render on a coarse integer fps grid (4fps → 0.25s accuracy, dropped
+// to 2/1fps for long timelines) instead of the composition's native 30fps.
+// Requested timestamps are snapped to that grid; the actually-captured time
+// is reported next to each written PNG.
+import { copyFileSync, cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { parseHTML } from "linkedom";
+import { inspectComposition } from "./composition-edit.js";
+const MAX_DEFAULT_STILLS = 8;
+const MAX_GRID_FRAMES = 600;
+// The in-process producer shells out to ffmpeg/ffprobe resolved from
+// HYPERFRAMES_FFMPEG_PATH / HYPERFRAMES_FFPROBE_PATH (then PATH). Point it at
+// the bundled static binaries, same as src/services/hyperframes.ts does.
+async function ensureProducerFfmpegEnv() {
+    if (!process.env.HYPERFRAMES_FFMPEG_PATH?.trim()) {
+        try {
+            const mod = (await import("ffmpeg-static"));
+            const resolved = typeof mod === "string" ? mod : mod.default;
+            if (typeof resolved === "string" && resolved && existsSync(resolved)) {
+                process.env.HYPERFRAMES_FFMPEG_PATH = resolved;
+            }
+        }
+        catch { /* PATH fallback */ }
+    }
+    if (!process.env.HYPERFRAMES_FFPROBE_PATH?.trim()) {
+        try {
+            const mod = (await import("ffprobe-static"));
+            const resolved = (mod.path ?? mod.default?.path);
+            if (typeof resolved === "string" && resolved && existsSync(resolved)) {
+                process.env.HYPERFRAMES_FFPROBE_PATH = resolved;
+            }
+        }
+        catch { /* PATH fallback */ }
+    }
+}
+/**
+ * Default timestamps when --at is omitted: the midpoint of each distinct
+ * scene clip on the LOWEST video track (capped at 8), else 0 / mid / end of
+ * the composition.
+ */
+export function defaultStillTimestamps(layers, durationSeconds) {
+    const isSceneClip = (layer) => layer.duration > 0 && (layer.is_timeline_proxy ||
+        layer.kind === "video" ||
+        layer.kind === "scene" ||
+        (layer.src !== null && /\.(mp4|mov|webm|m4v|mkv)(\?|#|$)/i.test(layer.src)) ||
+        // Canvas-filling clips of any kind read as scenes (image scenes,
+        // solid/title cards) — overlays/captions are never full-canvas.
+        layer.is_full_canvas);
+    const scenes = layers.filter(isSceneClip);
+    if (scenes.length > 0) {
+        const lowestTrack = Math.min(...scenes.map((layer) => layer.track));
+        const seen = new Set();
+        const midpoints = [];
+        for (const layer of scenes.filter((l) => l.track === lowestTrack).sort((a, b) => a.start - b.start)) {
+            const key = layer.key || `${layer.start}-${layer.duration}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            midpoints.push(layer.start + layer.duration / 2);
+            if (midpoints.length >= MAX_DEFAULT_STILLS)
+                break;
+        }
+        if (midpoints.length > 0)
+            return midpoints;
+    }
+    if (durationSeconds <= 0)
+        return [0];
+    return [...new Set([0, durationSeconds / 2, Math.max(0, durationSeconds - 0.5)])];
+}
+// Pick the coarsest integer fps grid that keeps capture cheap while staying
+// within 0.25s of any requested timestamp where possible.
+function pickGridFps(maxTimestamp) {
+    for (const fps of [4, 2, 1]) {
+        if ((maxTimestamp + 1) * fps <= MAX_GRID_FRAMES)
+            return fps;
+    }
+    return 1;
+}
+// Cap the staged copy's root data-duration so the producer never captures
+// frames past the last requested still.
+function capCompositionDuration(html, capSeconds) {
+    const { document } = parseHTML(html);
+    const root = document.querySelector("[data-composition-id]");
+    if (!root)
+        throw new Error("Composition root ([data-composition-id]) not found in composition.html.");
+    const existing = Number.parseFloat(root.getAttribute("data-duration") ?? "");
+    const capped = Number.isFinite(existing) && existing > 0 ? Math.min(existing, capSeconds) : capSeconds;
+    root.setAttribute("data-duration", String(Number(capped.toFixed(3))));
+    return `<!doctype html>\n${document.documentElement.outerHTML}`;
+}
+// Same guard as renderLocal: libx264-adjacent tooling (and the runtime's
+// canvas sizing) prefers even data-width/data-height.
+function forceEvenDimensions(html) {
+    return html.replace(/\bdata-(width|height)=(["'])(\d+)\2/gi, (match, dim, quote, value) => {
+        const n = Number.parseInt(value, 10);
+        if (!Number.isFinite(n) || n % 2 === 0)
+            return match;
+        return `data-${dim}=${quote}${n - 1}${quote}`;
+    });
+}
+/**
+ * Stage the composition as a HyperFrames project dir: the (duration-capped)
+ * composition.html becomes index.html, and every sibling file/dir is copied in
+ * so relative asset references keep resolving. Mirrors stageProject in
+ * src/services/hyperframes.ts, but against a local composition dir.
+ */
+function stageCompositionProject(htmlPath, stagedHtml) {
+    const sourceDir = path.dirname(htmlPath);
+    const projectDir = mkdtempSync(path.join(os.tmpdir(), "vidfarm-stills-"));
+    writeFileSync(path.join(projectDir, "index.html"), stagedHtml, "utf8");
+    for (const entry of readdirSync(sourceDir)) {
+        if (entry === path.basename(htmlPath) || entry === "index.html" || entry === "stills")
+            continue;
+        const from = path.join(sourceDir, entry);
+        try {
+            const info = statSync(from);
+            if (info.isDirectory()) {
+                cpSync(from, path.join(projectDir, entry), { recursive: true, force: true });
+            }
+            else if (info.isFile()) {
+                copyFileSync(from, path.join(projectDir, entry));
+            }
+        }
+        catch {
+            // best-effort: a missing/unreadable sibling never blocks the stills
+        }
+    }
+    return projectDir;
+}
+export async function renderCompositionStills(input) {
+    const html = readFileSync(input.htmlPath, "utf8");
+    if (!html.includes("data-composition-id=")) {
+        throw new Error(`stills requires composition HTML with data-composition-id (${input.htmlPath}).`);
+    }
+    const info = inspectComposition(html);
+    const durationSeconds = info.duration_seconds > 0 ? info.duration_seconds : 1;
+    const requested = (input.at && input.at.length > 0
+        ? input.at
+        : defaultStillTimestamps(info.layers, durationSeconds))
+        .map((t) => Math.min(Math.max(0, t), Math.max(0, durationSeconds - 0.01)))
+        .sort((a, b) => a - b);
+    if (requested.length === 0)
+        throw new Error("stills: no timestamps to render.");
+    const gridFps = pickGridFps(requested[requested.length - 1]);
+    const capSeconds = Math.min(durationSeconds, requested[requested.length - 1] + 2 / gridFps);
+    await ensureProducerFfmpegEnv();
+    const stagedHtml = forceEvenDimensions(capCompositionDuration(html, capSeconds));
+    const projectDir = stageCompositionProject(input.htmlPath, stagedHtml);
+    const framesDir = mkdtempSync(path.join(os.tmpdir(), "vidfarm-stills-frames-"));
+    const outDir = path.resolve(input.outDir ?? path.join(path.dirname(input.htmlPath), "stills"));
+    mkdirSync(outDir, { recursive: true });
+    // Declarative vidfarm compositions carry no scripts (cloud saves strip
+    // them), so they can never satisfy the engine's window.__timelines
+    // sub-composition poll — which otherwise stalls capture-session init for the
+    // full 45s playerReadyTimeout before proceeding anyway. When the html has no
+    // timeline registration at all, cap that wait via the engine's env knob.
+    // Compositions that DO register GSAP timelines keep the default.
+    const priorReadyTimeout = process.env.PRODUCER_PLAYER_READY_TIMEOUT_MS;
+    if (!priorReadyTimeout?.trim() && !stagedHtml.includes("__timelines")) {
+        process.env.PRODUCER_PLAYER_READY_TIMEOUT_MS = "10000";
+    }
+    try {
+        // Same producer entry points renderStill uses; "png-sequence" writes the
+        // frames dir as frame_000001.png … at 1/gridFps intervals.
+        const { createRenderJob, executeRenderJob } = await import("@hyperframes/producer");
+        // Quiet mode (--json) swaps in a no-op logger so stdout stays parseable —
+        // the producer's default logger writes progress lines to stdout.
+        const silentLogger = { error() { }, warn() { }, info() { }, debug() { } };
+        const job = createRenderJob({
+            fps: gridFps,
+            quality: "high",
+            format: "png-sequence",
+            ...(input.quiet ? { logger: silentLogger } : {})
+        });
+        let lastStatus = null;
+        const executeRender = () => executeRenderJob(job, projectDir, framesDir, (progressJob) => {
+            if (!input.quiet && progressJob.status !== lastStatus) {
+                lastStatus = progressJob.status;
+                console.log(`\x1b[2m  ${progressJob.status}\x1b[0m`);
+            }
+        });
+        // The engine also logs init/browser lines via console.log directly (they
+        // bypass the producer logger); in quiet mode reroute console stdout to
+        // stderr for the duration of the render so stdout stays pure JSON.
+        const originalConsole = { log: console.log, info: console.info, debug: console.debug };
+        if (input.quiet) {
+            const toStderr = (...args) => {
+                process.stderr.write(`${args.map((value) => (typeof value === "string" ? value : JSON.stringify(value))).join(" ")}\n`);
+            };
+            console.log = toStderr;
+            console.info = toStderr;
+            console.debug = toStderr;
+        }
+        try {
+            await executeRender();
+        }
+        finally {
+            console.log = originalConsole.log;
+            console.info = originalConsole.info;
+            console.debug = originalConsole.debug;
+        }
+        const frameFiles = readdirSync(framesDir)
+            .filter((name) => name.toLowerCase().endsWith(".png"))
+            .sort();
+        if (frameFiles.length === 0) {
+            throw new Error("stills render produced no frames — check the composition with `vidfarm lint` first.");
+        }
+        const stills = [];
+        for (const t of requested) {
+            const frameIndex = Math.min(frameFiles.length - 1, Math.max(0, Math.round(t * gridFps)));
+            const capturedSec = Number((frameIndex / gridFps).toFixed(3));
+            const stillName = `still-${capturedSec.toFixed(2).padStart(6, "0")}s.png`;
+            const dest = path.join(outDir, stillName);
+            copyFileSync(path.join(framesDir, frameFiles[frameIndex]), dest);
+            stills.push({ requested_sec: Number(t.toFixed(3)), captured_sec: capturedSec, path: dest });
+        }
+        return {
+            ok: true,
+            composition: input.htmlPath,
+            out_dir: outDir,
+            grid_fps: gridFps,
+            duration_seconds: durationSeconds,
+            stills
+        };
+    }
+    finally {
+        if (!priorReadyTimeout?.trim())
+            delete process.env.PRODUCER_PLAYER_READY_TIMEOUT_MS;
+        rmSync(framesDir, { recursive: true, force: true });
+        rmSync(projectDir, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=stills.js.map

package/dist/src/devcli/telemetry.js

@@ -0,0 +1,236 @@
+// Opt-out crash telemetry for the vidfarm devcli — the `vidfarm ...` commands
+// AND the local `serve` editor server. Unlike the backend/browser Sentry setups
+// (which run on OUR infrastructure), this runs on END USERS' machines, so it is
+// built defensively:
+//
+//   * DEDICATED DSN — never the backend or browser project. Ships EMPTY, i.e.
+//     fully DISABLED, until VIDFARM_DEVCLI_SENTRY_DSN (or the DEVCLI_SENTRY_DSN
+//     constant below) points at a Sentry project created specifically for the
+//     CLI. That keeps devcli crashes out of product error streams and means the
+//     published package never carries a DSN that could be abused for quota spam.
+//   * OPT-OUT — honors DO_NOT_TRACK (https://consoledonottrack.com) and
+//     VIDFARM_TELEMETRY=off|0|false|no|disabled.
+//   * CRASH-ONLY — deliberate `throw new Error("...")` user errors (bad args,
+//     HTTP 4xx, missing files) and transient network failures are NOT reported;
+//     only unexpected bugs (TypeError/RangeError/… and non-Error throws) are.
+//   * SCRUBBED — beforeSend strips home-dir paths, api keys, auth headers, and
+//     known env secrets before anything leaves the machine; PII is off; console
+//     breadcrumbs (which can carry prompts / composition text) are dropped.
+//   * FLUSHED — flushTelemetry() drains the queue before the short-lived CLI exits.
+//
+// Every entry point is wrapped so telemetry can NEVER break a user's command.
+import { readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import * as Sentry from "@sentry/node";
+// Set this to a DSN for a Sentry project dedicated to the devcli (NOT the
+// backend or browser project). Left empty so the published package is silent
+// until such a project exists; VIDFARM_DEVCLI_SENTRY_DSN overrides it at runtime.
+const DEVCLI_SENTRY_DSN = "";
+let initialized = false;
+// Env vars whose values must never leave the machine, even if they surface in
+// an error message or stack. Values are collected at init and redacted verbatim.
+const SECRET_ENV_KEYS = [
+    "VIDFARM_API_KEY",
+    "VIDFARM_STAGING_BOOTSTRAP_API_KEY",
+    "OPENAI_API_KEY",
+    "OPENROUTER_API_KEY",
+    "GEMINI_API_KEY",
+    "PERPLEXITY_API_KEY",
+    "GHOSTCUT_KEY",
+    "GHOSTCUT_SECRET",
+    "ENCRYPTION_SECRET",
+    "API_KEY_SALT",
+    "WEBHOOK_SECRET",
+    "RESEND_API_KEY",
+    "AWS_ACCESS_KEY_ID",
+    "AWS_SECRET_ACCESS_KEY"
+];
+const HOME_DIR = safeHomedir();
+let secretValues = [];
+// Token-shaped strings redacted regardless of source (belt-and-suspenders on top
+// of the exact env-value match above).
+const TOKEN_PATTERNS = [
+    /\b(?:vf|sk|rk|pk|key)_[A-Za-z0-9_-]{8,}\b/g, // vidfarm / provider-style keys
+    /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g, // JWT
+    /\bAKIA[0-9A-Z]{16}\b/g, // AWS access key id
+    /\bBearer\s+[A-Za-z0-9._~+/=-]+/gi
+];
+// Transient / environmental failures we never want to page on — they are the
+// user's network, not our bug.
+const BENIGN_MESSAGE = /(fetch failed|ECONNREFUSED|ECONNRESET|ENOTFOUND|ETIMEDOUT|EAI_AGAIN|socket hang up|getaddrinfo|network|and requires a connection)/i;
+function safeHomedir() {
+    try {
+        return os.homedir() || "";
+    }
+    catch {
+        return "";
+    }
+}
+function isOptedOut() {
+    // DO_NOT_TRACK: any value other than unset / "0" / "false" means opt out.
+    const dnt = process.env.DO_NOT_TRACK?.trim();
+    if (dnt && dnt !== "0" && dnt.toLowerCase() !== "false")
+        return true;
+    const flag = process.env.VIDFARM_TELEMETRY?.trim().toLowerCase();
+    if (flag && ["0", "off", "false", "no", "disabled"].includes(flag))
+        return true;
+    return false;
+}
+function resolveDsn() {
+    return (process.env.VIDFARM_DEVCLI_SENTRY_DSN?.trim() || DEVCLI_SENTRY_DSN || "").trim();
+}
+function readPackageVersion() {
+    try {
+        let dir = path.dirname(fileURLToPath(import.meta.url));
+        for (let i = 0; i < 6; i++) {
+            try {
+                const parsed = JSON.parse(readFileSync(path.join(dir, "package.json"), "utf8"));
+                if (parsed.name === "@officexapp/vidfarm-devcli" && parsed.version) {
+                    return `vidfarm-devcli@${parsed.version}`;
+                }
+            }
+            catch {
+                // keep walking up
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch {
+        // ignore — release tag is best-effort
+    }
+    return undefined;
+}
+function scrubString(input) {
+    let s = input;
+    if (HOME_DIR && s.includes(HOME_DIR))
+        s = s.split(HOME_DIR).join("~");
+    for (const secret of secretValues) {
+        if (secret && s.includes(secret))
+            s = s.split(secret).join("[REDACTED]");
+    }
+    for (const re of TOKEN_PATTERNS)
+        s = s.replace(re, "[REDACTED]");
+    // `--api-key <value>` on the command line and `header: value` shaped pairs.
+    s = s.replace(/(--api-key[=\s]+)\S+/gi, "$1[REDACTED]");
+    s = s.replace(/((?:vidfarm-api-key|authorization|x-api-key)["']?\s*[:=]\s*["']?)[^"'\s,}]+/gi, "$1[REDACTED]");
+    return s;
+}
+function scrubDeep(value, depth) {
+    if (value == null || depth > 8)
+        return value;
+    if (typeof value === "string")
+        return scrubString(value);
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++)
+            value[i] = scrubDeep(value[i], depth + 1);
+        return value;
+    }
+    if (typeof value === "object") {
+        const record = value;
+        for (const key of Object.keys(record))
+            record[key] = scrubDeep(record[key], depth + 1);
+        return record;
+    }
+    return value;
+}
+/** Deliberate `throw new Error("...")` user errors have name "Error"; genuine
+ *  bugs surface as TypeError/RangeError/ReferenceError/… or as non-Error throws.
+ *  Transient network failures are treated as expected. */
+export function isUnexpectedCrash(error) {
+    if (!(error instanceof Error))
+        return true;
+    if (BENIGN_MESSAGE.test(error.message))
+        return false;
+    return error.name !== "Error";
+}
+export function isTelemetryEnabled() {
+    return initialized;
+}
+export function initTelemetry(commandName) {
+    try {
+        if (initialized)
+            return;
+        if (isOptedOut())
+            return;
+        const dsn = resolveDsn();
+        if (!dsn)
+            return;
+        secretValues = SECRET_ENV_KEYS.map((key) => process.env[key]?.trim() ?? "").filter((v) => v.length >= 8);
+        Sentry.init({
+            dsn,
+            environment: "devcli",
+            release: process.env.VIDFARM_DEVCLI_RELEASE?.trim() || readPackageVersion(),
+            // Short-lived CLI: no performance tracing, no log capture (logs can carry
+            // prompts / composition text), tiny breadcrumb budget.
+            tracesSampleRate: 0,
+            enableLogs: false,
+            sendDefaultPii: false,
+            maxBreadcrumbs: 20,
+            beforeBreadcrumb(breadcrumb) {
+                if (breadcrumb.category === "console")
+                    return null;
+                try {
+                    return scrubDeep(breadcrumb, 0);
+                }
+                catch {
+                    return null; // if scrubbing fails, drop rather than risk leaking
+                }
+            },
+            beforeSend(event) {
+                try {
+                    if (event.request) {
+                        delete event.request.data;
+                        delete event.request.cookies;
+                        delete event.request.headers;
+                    }
+                    return scrubDeep(event, 0);
+                }
+                catch {
+                    return null; // scrub failed → drop the event entirely, never leak raw
+                }
+            }
+        });
+        Sentry.setTags({
+            "vidfarm.surface": "devcli",
+            "vidfarm.node": process.version,
+            "vidfarm.platform": `${process.platform}-${process.arch}`,
+            ...(commandName ? { "vidfarm.command": commandName } : {})
+        });
+        initialized = true;
+    }
+    catch {
+        // Telemetry must never break the CLI.
+        initialized = false;
+    }
+}
+/** Report an unexpected top-level CLI crash (no-op for expected user errors,
+ *  transient network errors, or when telemetry is disabled), then flush. */
+export async function reportCliCrash(error) {
+    try {
+        if (!initialized)
+            return;
+        if (!isUnexpectedCrash(error))
+            return;
+        Sentry.captureException(error);
+        await flushTelemetry();
+    }
+    catch {
+        // swallow — never let telemetry change the exit path
+    }
+}
+export async function flushTelemetry(timeoutMs = 2000) {
+    try {
+        if (!initialized)
+            return;
+        await Sentry.flush(timeoutMs);
+    }
+    catch {
+        // swallow
+    }
+}
+//# sourceMappingURL=telemetry.js.map