storyforge 0.6.0 → 0.7.0

package/dist/index.js

@@ -2,6 +2,7 @@
 import {
   log
 } from "./chunk-GJQ45C5W.js";
+import "./chunk-NSPRIPOP.js";
 
 // src/commands/dev.ts
 import * as fs2 from "fs";
@@ -840,7 +841,7 @@ async function devCommand(options) {
   }
   void (async () => {
     try {
-      const { gatherCliUsage, CLI_USAGE_PARSER_VERSION } = await import("./cli-usage-FG3YUG3W.js");
+      const { gatherCliUsage, CLI_USAGE_PARSER_VERSION } = await import("./cli-usage-G762TREV.js");
       const report = await gatherCliUsage();
       const g = global;
       g.__forgeCliUsageCache = { at: Date.now(), ver: CLI_USAGE_PARSER_VERSION, data: report };
@@ -876,7 +877,7 @@ async function devCommand(options) {
     const pathname = url.pathname;
     if (pathname === "/api/cli-usage") {
       try {
-        const { gatherCliUsage, CLI_USAGE_PARSER_VERSION } = await import("./cli-usage-FG3YUG3W.js");
+        const { gatherCliUsage, CLI_USAGE_PARSER_VERSION } = await import("./cli-usage-G762TREV.js");
         const g = global;
         const now = Date.now();
         if (g.__forgeCliUsageCache && g.__forgeCliUsageCache.ver === CLI_USAGE_PARSER_VERSION && now - g.__forgeCliUsageCache.at < 3e4) {
@@ -1614,7 +1615,7 @@ Return ONLY the complete updated TSX. No markdown fences, no explanation.`;
         return "0.0.0";
       })();
       void (async () => {
-        const { BridgePoller } = await import("./bridge-poller-MM6K2GKM.js");
+        const { BridgePoller } = await import("./bridge-poller-JIP6RGMN.js");
         const poller = new BridgePoller({ baseUrl: bridgeUrl, token: bridgeToken, clientVersion: `storyforge ${pkgVersion}` });
         poller.start();
       })();
@@ -1678,15 +1679,329 @@ async function loginCommand() {
   }
 }
 
+// src/commands/doctor.ts
+import { spawn as spawn2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { execFile as execFileCb } from "child_process";
+import os3 from "os";
+var execFile2 = promisify2(execFileCb);
+async function runDoctor() {
+  const platform = os3.platform();
+  const arch = os3.arch();
+  const cores = os3.cpus().length;
+  const ramGb = Math.round(os3.totalmem() / 1024 ** 3);
+  const renderers = await Promise.all([
+    checkFfmpeg(platform),
+    checkPython(),
+    checkManim(),
+    checkHyperframes(),
+    checkChromeHeadlessShell(platform),
+    checkNode(),
+    checkNpm()
+  ]);
+  const ready = renderers.filter((r) => r.required).every((r) => r.installed);
+  return { platform, arch, cores, ramGb, renderers, ready };
+}
+function formatDoctorReport(r) {
+  const lines = [];
+  lines.push(`storyforge doctor`);
+  lines.push(`  platform: ${r.platform} \xB7 ${r.arch} \xB7 ${r.cores} cores \xB7 ${r.ramGb} GB RAM`);
+  lines.push("");
+  for (const dep of r.renderers) {
+    const tick = dep.installed ? "\x1B[32m\u2713\x1B[0m" : dep.required ? "\x1B[31m\u2717\x1B[0m" : "\x1B[33m\u25CB\x1B[0m";
+    const ver = dep.version ? ` (${dep.version})` : "";
+    const need = dep.required ? "" : "  [optional]";
+    lines.push(`  ${tick} ${dep.name.padEnd(28)}${ver}${need}`);
+    if (!dep.installed && dep.installCommand) {
+      lines.push(`        install: ${dep.installCommand}`);
+    }
+  }
+  lines.push("");
+  if (r.ready) {
+    lines.push(`\x1B[32m\u2713 ready to render.\x1B[0m  next: \`storyforge\` to start the bridge.`);
+  } else {
+    lines.push(`\x1B[33m! missing required renderers.\x1B[0m  run: \`storyforge install-renderers\` to install them.`);
+  }
+  return lines.join("\n");
+}
+async function probeVersion(cmd, args = ["--version"], parser = firstLine) {
+  try {
+    const { stdout, stderr } = await execFile2(cmd, args, { timeout: 5e3 });
+    const out = (stdout || stderr || "").trim();
+    return { installed: true, version: parser(out) };
+  } catch {
+    return { installed: false, version: null };
+  }
+}
+function firstLine(s) {
+  return s.split("\n")[0]?.trim().slice(0, 80) ?? null;
+}
+async function checkFfmpeg(platform) {
+  const probe = await probeVersion("ffmpeg", ["-version"], (s) => {
+    const m = s.match(/ffmpeg version (\S+)/);
+    return m?.[1] ?? null;
+  });
+  return {
+    name: "ffmpeg",
+    installed: probe.installed,
+    version: probe.version,
+    rationale: "concat + audio mux + watermark \u2014 required by every engine",
+    installCommand: platform === "darwin" ? "brew install ffmpeg" : platform === "linux" ? "sudo apt install -y ffmpeg" : "https://ffmpeg.org/download.html",
+    required: true
+  };
+}
+async function checkPython() {
+  const probe = await probeVersion("python3", ["--version"], (s) => {
+    const m = s.match(/Python (\S+)/);
+    return m?.[1] ?? null;
+  });
+  return {
+    name: "python3",
+    installed: probe.installed,
+    version: probe.version,
+    rationale: "manim engine runtime",
+    installCommand: os3.platform() === "darwin" ? "brew install python@3.12" : "sudo apt install -y python3",
+    required: false
+  };
+}
+async function checkManim() {
+  const probe = await new Promise((resolve3) => {
+    const p = spawn2("python3", ["-m", "manim", "--version"], { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    p.stdout.on("data", (d) => {
+      stdout += d.toString("utf8");
+    });
+    p.stderr.on("data", (d) => {
+      stderr += d.toString("utf8");
+    });
+    p.on("error", () => resolve3({ installed: false, version: null }));
+    p.on("close", (code) => {
+      if (code === 0) {
+        const m = (stdout + stderr).match(/Manim Community v(\S+)/);
+        resolve3({ installed: true, version: m?.[1] ?? null });
+      } else {
+        resolve3({ installed: false, version: null });
+      }
+    });
+    setTimeout(() => {
+      p.kill();
+      resolve3({ installed: false, version: null });
+    }, 5e3);
+  });
+  return {
+    name: "manim (python pkg)",
+    installed: probe.installed,
+    version: probe.version,
+    rationale: "3Blue1Brown-style mathematical animations",
+    installCommand: "python3 -m pip install --user manim",
+    required: false
+  };
+}
+async function checkHyperframes() {
+  const probe = await probeVersion("hyperframes", ["--version"]);
+  return {
+    name: "hyperframes",
+    installed: probe.installed,
+    version: probe.version,
+    rationale: "GSAP / Three.js / Lottie cascades (Stage 2 engine)",
+    installCommand: "npm install -g hyperframes",
+    required: false
+  };
+}
+async function checkChromeHeadlessShell(platform) {
+  if (platform !== "linux") {
+    return {
+      name: "chrome-headless-shell",
+      installed: false,
+      version: null,
+      rationale: "hyperframes deterministic mode (Linux only \u2014 macOS uses screenshot fallback)",
+      installCommand: null,
+      required: false
+    };
+  }
+  const probe = await probeVersion("chrome-headless-shell", ["--version"]);
+  return {
+    name: "chrome-headless-shell",
+    installed: probe.installed,
+    version: probe.version,
+    rationale: "hyperframes deterministic BeginFrame mode",
+    installCommand: "npx puppeteer browsers install chrome-headless-shell",
+    required: false
+  };
+}
+async function checkNode() {
+  const probe = await probeVersion("node", ["--version"]);
+  return {
+    name: "node",
+    installed: probe.installed,
+    version: probe.version,
+    rationale: "Remotion + JS pipeline runtime",
+    installCommand: "https://nodejs.org/",
+    required: true
+  };
+}
+async function checkNpm() {
+  const probe = await probeVersion("npm", ["--version"]);
+  return {
+    name: "npm",
+    installed: probe.installed,
+    version: probe.version,
+    rationale: "Remotion + hyperframes installer",
+    installCommand: "comes with node",
+    required: true
+  };
+}
+async function doctorCommand() {
+  const report = await runDoctor();
+  console.log(formatDoctorReport(report));
+  process.exit(report.ready ? 0 : 1);
+}
+
+// src/commands/install-renderers.ts
+import { spawn as spawn3 } from "child_process";
+import readline2 from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+import os4 from "os";
+function planInstall(missing, platform) {
+  const steps = [];
+  for (const r of missing) {
+    if (r.installed) continue;
+    switch (r.name) {
+      case "ffmpeg": {
+        if (platform === "darwin") {
+          steps.push({ name: "ffmpeg", argv: ["brew", "install", "ffmpeg"], display: "brew install ffmpeg" });
+        } else if (platform === "linux") {
+          steps.push({ name: "ffmpeg", argv: ["sudo", "apt", "install", "-y", "ffmpeg"], display: "sudo apt install -y ffmpeg" });
+        } else {
+          steps.push({ name: "ffmpeg", argv: null, display: r.installCommand ?? "see ffmpeg.org", manual: true });
+        }
+        break;
+      }
+      case "python3": {
+        if (platform === "darwin") {
+          steps.push({ name: "python3", argv: ["brew", "install", "python@3.12"], display: "brew install python@3.12" });
+        } else if (platform === "linux") {
+          steps.push({ name: "python3", argv: ["sudo", "apt", "install", "-y", "python3", "python3-pip"], display: "sudo apt install -y python3 python3-pip" });
+        } else {
+          steps.push({ name: "python3", argv: null, display: "install Python 3 from python.org", manual: true });
+        }
+        break;
+      }
+      case "manim (python pkg)": {
+        steps.push({ name: "manim (python pkg)", argv: ["python3", "-m", "pip", "install", "--user", "manim"], display: "python3 -m pip install --user manim" });
+        break;
+      }
+      case "hyperframes": {
+        steps.push({ name: "hyperframes", argv: ["npm", "install", "-g", "hyperframes"], display: "npm install -g hyperframes" });
+        break;
+      }
+      case "chrome-headless-shell": {
+        if (platform === "linux") {
+          steps.push({ name: "chrome-headless-shell", argv: ["npx", "puppeteer", "browsers", "install", "chrome-headless-shell"], display: "npx puppeteer browsers install chrome-headless-shell" });
+        }
+        break;
+      }
+      case "node":
+      case "npm":
+        steps.push({ name: r.name, argv: null, display: r.installCommand ?? "install Node.js from nodejs.org", manual: true });
+        break;
+    }
+  }
+  return steps;
+}
+async function ask(rl, question) {
+  const ans = (await rl.question(question)).trim().toLowerCase();
+  return ans === "" || ans === "y" || ans === "yes";
+}
+function runStep(argv) {
+  return new Promise((resolve3) => {
+    const [cmd, ...args] = argv;
+    const proc = spawn3(cmd, args, { stdio: ["inherit", "inherit", "inherit"] });
+    proc.on("error", (err) => resolve3({ ok: false, tail: err.message }));
+    proc.on("close", (code) => resolve3({ ok: code === 0 }));
+  });
+}
+async function installRenderersCommand(opts = {}) {
+  console.log("\x1B[1mstoryforge install-renderers\x1B[0m\n");
+  const report = await runDoctor();
+  const missing = report.renderers.filter((r) => !r.installed && r.installCommand);
+  if (missing.length === 0) {
+    console.log("\x1B[32m\u2713 all renderers already installed.\x1B[0m");
+    process.exit(0);
+  }
+  const steps = planInstall(missing, report.platform);
+  if (steps.length === 0) {
+    console.log("\x1B[33m! nothing to install on this platform \u2014 run `storyforge doctor` for the manual install hints.\x1B[0m");
+    process.exit(1);
+  }
+  console.log(`Detected ${steps.length} missing renderer${steps.length === 1 ? "" : "s"}:`);
+  for (const s of steps) {
+    console.log(`  \u2022 ${s.name.padEnd(28)} \u2192 ${s.display}${s.manual ? "  [manual]" : ""}`);
+  }
+  console.log("");
+  const rl = readline2.createInterface({ input, output });
+  let installed = 0;
+  let skipped = 0;
+  let failed = [];
+  try {
+    for (const step of steps) {
+      if (step.manual || !step.argv) {
+        console.log(`\x1B[33m\u25B8 ${step.name}\x1B[0m \u2014 manual install: ${step.display}`);
+        skipped++;
+        continue;
+      }
+      const proceed = opts.yes ? true : await ask(rl, `Install \x1B[1m${step.name}\x1B[0m via \x1B[36m${step.display}\x1B[0m? [Y/n] `);
+      if (!proceed) {
+        console.log(`  skipped ${step.name}.`);
+        skipped++;
+        continue;
+      }
+      console.log(`
+\x1B[36m\u25B8 ${step.display}\x1B[0m`);
+      const result = await runStep(step.argv);
+      if (result.ok) {
+        console.log(`\x1B[32m  \u2713 ${step.name} installed.\x1B[0m
+`);
+        installed++;
+      } else {
+        console.log(`\x1B[31m  \u2717 ${step.name} install failed.\x1B[0m
+`);
+        failed.push(step.name);
+      }
+    }
+  } finally {
+    rl.close();
+  }
+  console.log("");
+  console.log(`Installed: ${installed} \xB7 Skipped: ${skipped} \xB7 Failed: ${failed.length}`);
+  if (failed.length > 0) {
+    console.log(`\x1B[31m  failed: ${failed.join(", ")}\x1B[0m`);
+  }
+  console.log("\nRe-probing\u2026\n");
+  const after = await runDoctor();
+  const stillMissing = after.renderers.filter((r) => !r.installed && r.required);
+  if (stillMissing.length === 0) {
+    console.log("\x1B[32m\u2713 ready to render.\x1B[0m  next: `storyforge` to start the bridge.");
+    process.exit(0);
+  } else {
+    console.log(`\x1B[33m! still missing required: ${stillMissing.map((r) => r.name).join(", ")}\x1B[0m`);
+    console.log("  run `storyforge doctor` to see install hints.");
+    process.exit(1);
+  }
+}
+
 // src/index.ts
-var VERSION = "0.1.0";
+var VERSION = "0.7.0";
 var HELP = `
 storyforge \u2014 local bridge for the Forge video production web app
 
 Usage:
-  storyforge                       Auto-link current folder, start server, open browser (default)
-  storyforge [options]
-  storyforge login                 Log in
+  storyforge                       Auto-link current folder, start bridge, open browser (default)
+  storyforge login                 Log in to forge.algo-thinker.com
+  storyforge doctor                Probe local renderers (ffmpeg / python / manim / hyperframes)
+  storyforge install-renderers     Install missing renderers (interactive, asks per-tool)
+  storyforge install-renderers -y  Same, but auto-confirm every prompt
   storyforge --help                Show this help
   storyforge --version             Show version
 
@@ -1695,6 +2010,14 @@ Options:
   --dir <dir>        Project directory (default: current)
   --no-open          Do not open browser automatically
 
+First-time setup:
+  npm install -g storyforge
+  storyforge login
+  storyforge doctor              # see what's missing
+  storyforge install-renderers   # ffmpeg + python + manim + hyperframes
+  cd /path/to/your/project
+  storyforge                     # links project, starts bridge, opens browser
+
 In any folder with assets (audio/, images-horizontal/, images-vertical/, scripts/),
 just run: storyforge
 `.trim();
@@ -1733,6 +2056,15 @@ async function main() {
     await loginCommand();
     return;
   }
+  if (firstArg === "doctor") {
+    await doctorCommand();
+    return;
+  }
+  if (firstArg === "install-renderers" || firstArg === "install") {
+    const yes = args.includes("-y") || args.includes("--yes");
+    await installRenderersCommand({ yes });
+    return;
+  }
   const opts = parseArgs(args);
   await devCommand({
     port: typeof opts.port === "string" ? opts.port : void 0,