@mevdragon/vidfarm-devcli 0.13.0 → 0.15.0

package/dist/src/devcli/doctor.js

@@ -0,0 +1,192 @@
+// `vidfarm doctor` — one-shot health check of everything the devcli's local
+// loops depend on: node, the bundled ffmpeg/ffprobe, the hyperframes local
+// engines, Chrome for in-process rendering, cloud auth, provider keys, agent
+// CLIs, poisoned-env traps, port 3000, and installed agent skills.
+//
+// Exit code: 0 unless a HARD requirement (ffmpeg) is missing — everything
+// 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 net from "node:net";
+import { homedir } from "node:os";
+import path from "node:path";
+import { parseArgs } from "node:util";
+import { detectLocalAgent } from "../services/clip-curation/index.js";
+import { hasFfmpeg, resolveFfmpeg, resolveFfprobe } from "../services/clip-curation/ffmpeg.js";
+import { resolveHyperframesCli } from "./hyperframes-cli.js";
+import { resolveSkillsRoot } from "./skills.js";
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const YELLOW = "\x1b[33m";
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+// The cloud ARNs/URLs the `serve` command blanks before booting (see
+// runServeCommand in src/cli.ts). Any of these set in a plain dev shell will
+// silently route local work to cloud infra — the classic poisoned-.env trap.
+const SERVE_BLANKED_ENV_VARS = [
+    "VIDFARM_JOB_STATE_MACHINE_ARN",
+    "VIDFARM_CLIP_SCAN_STATE_MACHINE_ARN",
+    "VIDFARM_PRIMITIVE_MEDIA_LAMBDA_URL",
+    "VIDFARM_PRIMITIVE_MEDIA_LAMBDA_SECRET",
+    "AWS_S3_BUCKET"
+];
+const PROVIDER_KEY_ENV_VARS = ["OPENAI_API_KEY", "GEMINI_API_KEY", "OPENROUTER_API_KEY", "ELEVENLABS_API_KEY"];
+function isPortInUse(port) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once("error", (error) => {
+            resolve(error.code === "EADDRINUSE");
+        });
+        server.once("listening", () => {
+            server.close(() => resolve(false));
+        });
+        server.listen(port, "127.0.0.1");
+    });
+}
+// Best-effort Chrome availability for the in-process HyperFrames render:
+// explicit env overrides, the puppeteer download cache, or a system Chrome.
+function detectChromeForRender() {
+    for (const envName of ["PUPPETEER_EXECUTABLE_PATH", "CHROME_PATH", "HYPERFRAMES_CHROME_PATH"]) {
+        const value = process.env[envName]?.trim();
+        if (value && existsSync(value))
+            return { found: true, detail: `${envName}=${value}` };
+    }
+    const cacheDir = process.env.PUPPETEER_CACHE_DIR?.trim() || path.join(homedir(), ".cache", "puppeteer");
+    try {
+        const entries = readdirSync(cacheDir).filter((name) => /chrome/i.test(name));
+        if (entries.length > 0)
+            return { found: true, detail: `puppeteer cache ${cacheDir} (${entries.join(", ")})` };
+    }
+    catch {
+        // no cache dir — fall through
+    }
+    const systemCandidates = process.platform === "darwin"
+        ? ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome", "/Applications/Chromium.app/Contents/MacOS/Chromium"]
+        : ["/usr/bin/google-chrome", "/usr/bin/chromium", "/usr/bin/chromium-browser"];
+    for (const candidate of systemCandidates) {
+        if (existsSync(candidate))
+            return { found: true, detail: candidate };
+    }
+    return { found: false, detail: `no PUPPETEER_EXECUTABLE_PATH/CHROME_PATH, no ${cacheDir}, no system Chrome` };
+}
+// Count installed skills under the SAME root the `vidfarm skills` command
+// resolves (resolveSkillsRoot: walk up from cwd to the first dir with
+// .agents/skills or .git, else cwd) — one resolution, no drift.
+function countInstalledSkills() {
+    const root = resolveSkillsRoot();
+    const skillsDir = path.join(root, ".agents", "skills");
+    if (!existsSync(skillsDir))
+        return { root: null, count: 0, names: [] };
+    try {
+        const names = readdirSync(skillsDir).filter((name) => existsSync(path.join(skillsDir, name, "SKILL.md")));
+        return { root, count: names.length, names };
+    }
+    catch {
+        return { root, count: 0, names: [] };
+    }
+}
+async function fetchWhoami(host, apiKey) {
+    try {
+        const res = await fetch(new URL("/api/v1/user/me", host), {
+            headers: { "vidfarm-api-key": apiKey, accept: "application/json" }
+        });
+        if (!res.ok)
+            return { ok: false, detail: `GET /api/v1/user/me → ${res.status} (check the key/host)` };
+        const json = await res.json().catch(() => null);
+        const email = json?.email ?? json?.user?.email ?? json?.customer?.email;
+        return { ok: true, detail: email ? `authenticated as ${email} (${host})` : `authenticated (${host})` };
+    }
+    catch (error) {
+        return { ok: false, detail: `could not reach ${host}: ${error instanceof Error ? error.message : String(error)}` };
+    }
+}
+export async function runDoctorCommand(argv) {
+    const parsed = parseArgs({
+        args: argv,
+        allowPositionals: false,
+        options: {
+            host: { type: "string", default: "https://vidfarm.cc" },
+            "api-key": { type: "string" },
+            json: { type: "boolean", default: false }
+        }
+    });
+    const json = Boolean(parsed.values.json);
+    const checks = [];
+    const add = (name, level, detail) => checks.push({ name, level, detail });
+    // 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"}`);
+    // 2. ffmpeg / ffprobe (HARD requirement).
+    const ffmpegPath = await resolveFfmpeg();
+    const ffprobePath = await resolveFfprobe();
+    const ffmpegOk = await hasFfmpeg();
+    add("ffmpeg", ffmpegOk ? "ok" : "fail", ffmpegOk ? ffmpegPath : "not found (bundled ffmpeg-static missing and none on PATH) — media commands cannot run");
+    add("ffprobe", existsSync(ffprobePath) || spawnSync(ffprobePath, ["-version"], { stdio: "ignore" }).status === 0 ? "ok" : "warn", ffprobePath);
+    // 3. hyperframes CLI (local engines: Kokoro tts, whisper stt, matting, capture, beats).
+    const hyperframesCli = resolveHyperframesCli();
+    add("hyperframes", hyperframesCli ? "ok" : "warn", hyperframesCli ?? "not installed — local engines (tts/transcribe/remove-background/capture/beats) will fall back to `npx -y hyperframes`");
+    // 4. Chrome for the in-process render (stills / serve local render).
+    const chrome = detectChromeForRender();
+    add("chrome", chrome.found ? "ok" : "warn", chrome.found ? chrome.detail : `${chrome.detail} — local render/stills will try to download one on first run`);
+    // 5. Vidfarm cloud auth.
+    const apiKey = parsed.values["api-key"] ?? process.env.VIDFARM_API_KEY;
+    if (apiKey) {
+        const who = await fetchWhoami(String(parsed.values.host).replace(/\/+$/, ""), apiKey);
+        add("vidfarm auth", who.ok ? "ok" : "warn", who.detail);
+    }
+    else {
+        add("vidfarm auth", "warn", "VIDFARM_API_KEY not set — cloud commands need it (local serve/lint/stills/speech engines work without it)");
+    }
+    // 6. Provider keys in env (BYOK local-first engines).
+    const presentKeys = PROVIDER_KEY_ENV_VARS.filter((name) => process.env[name]?.trim());
+    add("provider keys", presentKeys.length > 0 ? "ok" : "warn", presentKeys.length > 0
+        ? presentKeys.join(", ")
+        : "none of OPENAI/GEMINI/OPENROUTER/ELEVENLABS_API_KEY set — BYOK speech/clip tagging unavailable (keyless local engines still work)");
+    // 7. Local agent CLI (claude / codex) for clips scan etc.
+    const agent = detectLocalAgent();
+    add("agent CLI", agent ? "ok" : "warn", agent ? `${agent.kind} (${agent.bin})` : "no claude/codex CLI on PATH — `clips scan` falls back to provider keys");
+    // 8. Poisoned-env traps.
+    if (process.env.AWS_PROFILE?.trim()) {
+        add("env AWS_PROFILE", "warn", `AWS_PROFILE=${process.env.AWS_PROFILE} is set — it can hijack AWS SDK auth; run \`env -u AWS_PROFILE\` or unset it`);
+    }
+    else {
+        add("env AWS_PROFILE", "ok", "not set");
+    }
+    const poisoned = SERVE_BLANKED_ENV_VARS.filter((name) => process.env[name]?.trim());
+    add("env cloud ARNs/URLs", poisoned.length > 0 ? "warn" : "ok", poisoned.length > 0
+        ? `${poisoned.join(", ")} set — outside \`vidfarm serve\` these route local work to cloud infra (serve blanks them itself)`
+        : "no stray cloud ARNs/URLs in env");
+    // 9. Port 3000 (default serve port).
+    const portBusy = await isPortInUse(3000);
+    add("port 3000", portBusy ? "warn" : "ok", portBusy ? "in use — a serve box may already be running (or pass --port to serve)" : "free");
+    // 10. HeyGen credential file — vidfarm never uses it.
+    const heygenCredentials = path.join(homedir(), ".heygen", "credentials");
+    if (existsSync(heygenCredentials) || existsSync(path.join(homedir(), ".heygen", "credentials.json"))) {
+        add("heygen credentials", "warn", "found a HeyGen credential file — vidfarm never uses it; local engines and vidfarm BYOK keys are the only auth");
+    }
+    else {
+        add("heygen credentials", "ok", "none (vidfarm never uses HeyGen accounts)");
+    }
+    // 11. Installed agent skills.
+    const skills = countInstalledSkills();
+    add("agent skills", skills.count > 0 ? "ok" : "warn", skills.count > 0
+        ? `${skills.count} installed under ${skills.root}/.agents/skills`
+        : "no .agents/skills found walking up from cwd — run `vidfarm skills add <names…>`");
+    const ffmpegMissing = checks.some((check) => check.name === "ffmpeg" && check.level === "fail");
+    if (json) {
+        process.stdout.write(`${JSON.stringify({ ok: !ffmpegMissing, checks }, null, 2)}\n`);
+    }
+    else {
+        for (const check of checks) {
+            const mark = check.level === "ok" ? `${GREEN}✓${RESET}` : check.level === "warn" ? `${YELLOW}⚠${RESET}` : `${RED}✗${RESET}`;
+            console.log(`${mark} ${check.name.padEnd(20)} ${DIM}${check.detail}${RESET}`);
+        }
+        if (ffmpegMissing) {
+            console.log(`\n${RED}ffmpeg is a hard requirement — install it (or \`npm i ffmpeg-static\`) and re-run.${RESET}`);
+        }
+    }
+    if (ffmpegMissing)
+        process.exitCode = 1;
+}
+//# sourceMappingURL=doctor.js.map

package/dist/src/devcli/hyperframes-cli.js

@@ -0,0 +1,118 @@
+// Guarded bridge to the bundled `hyperframes` npm CLI — the devcli's local
+// media engine. Only the LOCAL, account-free commands are reachable through
+// this module (tts / transcribe / remove-background / capture / beats / …);
+// the HeyGen account + telemetry surface (`auth`, `cloud`, `publish`, `play`,
+// `feedback`, `telemetry`) is rejected outright so no vidfarm command can ever
+// touch a HeyGen account, even by accident.
+//
+// Every spawn additionally hardens the child env:
+//   - HYPERFRAMES_NO_TELEMETRY=1  → no anonymous usage pings
+//   - HYPERFRAMES_SKIP_SKILLS=1   → no skill-install prompts in pipelines
+//   - HEYGEN_CONFIG_DIR=<fresh empty temp dir> → a stray ~/.heygen credential
+//     can NEVER be picked up (some hyperframes commands silently flip their
+//     audio-provider preference when a HeyGen credential is present).
+import { spawn } from "node:child_process";
+import { mkdtempSync } from "node:fs";
+import { createRequire } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const BLOCKED_SUBCOMMANDS = new Set(["auth", "cloud", "publish", "play", "feedback", "telemetry"]);
+/**
+ * Locate the bundled hyperframes CLI entrypoint by walking node_modules from
+ * this module's directory first (the published devcli package carries the
+ * dependency), then from process.cwd() (running inside a repo that installed
+ * it). Returns null when the package is not installed anywhere reachable.
+ */
+export function resolveHyperframesCli() {
+    const anchors = [path.dirname(fileURLToPath(import.meta.url)), process.cwd()];
+    for (const anchor of anchors) {
+        try {
+            const localRequire = createRequire(path.join(anchor, "__resolve__.js"));
+            return localRequire.resolve("hyperframes/dist/cli.js");
+        }
+        catch {
+            // keep walking — try the next anchor
+        }
+    }
+    return null;
+}
+/**
+ * Run `hyperframes <subcommand> ...args` with the hardened env described in
+ * the module header. Falls back to `npx -y hyperframes` when the package
+ * cannot be resolved locally. Throws on blocked subcommands; resolves with
+ * the exit code + captured output (empty strings in inherit mode).
+ */
+export async function runHyperframesCommand(subcommand, args, opts = {}) {
+    if (BLOCKED_SUBCOMMANDS.has(subcommand)) {
+        throw new Error(`hyperframes ${subcommand} is blocked: vidfarm never uses HeyGen accounts or telemetry. ` +
+            "Local engines and vidfarm BYOK keys are the only auth.");
+    }
+    const cli = resolveHyperframesCli();
+    // Fresh empty config dir per invocation — guarantees no ~/.heygen credential
+    // (or any other persisted account state) leaks into the child process.
+    const emptyConfigDir = mkdtempSync(path.join(os.tmpdir(), "vidfarm-hf-noauth-"));
+    const env = {
+        ...process.env,
+        HYPERFRAMES_NO_TELEMETRY: "1",
+        HYPERFRAMES_SKIP_SKILLS: "1",
+        HEYGEN_CONFIG_DIR: emptyConfigDir,
+        ...opts.env
+    };
+    const [bin, baseArgs] = cli
+        ? [process.execPath, [cli]]
+        : ["npx", ["-y", "hyperframes"]];
+    const capture = opts.stdio === "capture";
+    return new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn(bin, [...baseArgs, subcommand, ...args], {
+            cwd: opts.cwd,
+            env,
+            stdio: capture ? ["ignore", "pipe", "pipe"] : "inherit"
+        });
+        let stdout = "";
+        let stderr = "";
+        if (capture) {
+            child.stdout?.on("data", (chunk) => (stdout += chunk.toString()));
+            child.stderr?.on("data", (chunk) => (stderr += chunk.toString()));
+        }
+        child.on("error", (error) => {
+            rejectPromise(error.code === "ENOENT"
+                ? new Error("Could not launch the hyperframes CLI (not installed and npx unavailable). Run `npm i hyperframes` in your project.")
+                : error);
+        });
+        child.on("close", (code) => {
+            resolvePromise({ code: code ?? 1, stdout, stderr });
+        });
+    });
+}
+/** Parse the last JSON object printed by a captured hyperframes --json run
+ * (tolerates both compact single-line and pretty multi-line output, with log
+ * lines interleaved before it). */
+export function parseHyperframesJson(output) {
+    const trimmed = output.trim();
+    if (!trimmed)
+        return null;
+    // Whole output is the JSON document (the common --json case).
+    try {
+        const whole = JSON.parse(trimmed);
+        if (whole && typeof whole === "object")
+            return whole;
+    }
+    catch { /* fall through */ }
+    // Log lines first, JSON at the end: parse from each line that opens an
+    // object through the end of the output, scanning bottom-up.
+    const lines = trimmed.split("\n");
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+        if (!lines[i].trimStart().startsWith("{"))
+            continue;
+        const candidate = lines.slice(i).join("\n").trim();
+        try {
+            const parsed = JSON.parse(candidate);
+            if (parsed && typeof parsed === "object")
+                return parsed;
+        }
+        catch { /* keep scanning upward */ }
+    }
+    return null;
+}
+//# sourceMappingURL=hyperframes-cli.js.map