@devinilabs/reelstack 1.2.0

package/cli/icons.js

@@ -0,0 +1,49 @@
+/**
+ * `reelstack icons <brand> [<brand2> …]` — pull real brand SVGs via the
+ * better-icons CLI into public/icons/.
+ *
+ * House rule: never hand-draw a brand mark when Iconify has the real SVG.
+ */
+const fs = require("node:fs");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+const { info, success, fail, warn, c, which } = require("./utils");
+
+async function run(argv) {
+  const brands = argv.filter((a) => !a.startsWith("--"));
+  if (brands.length === 0) {
+    fail("Usage: reelstack icons <brand> [<brand2> …]");
+    process.exit(2);
+  }
+  const betterIcons = which("better-icons");
+  if (!betterIcons) {
+    fail("better-icons CLI not found. Install: npm i -g better-icons");
+    process.exit(2);
+  }
+
+  const outDir = path.join(process.cwd(), "public", "icons");
+  fs.mkdirSync(outDir, { recursive: true });
+
+  for (const brand of brands) {
+    const id = brand.includes(":") ? brand : `logos:${brand}`;
+    const out = path.join(outDir, `${brand.replace(":", "-")}.svg`);
+    info(`Fetching ${id} → ${path.relative(process.cwd(), out)}…`);
+    const result = spawnSync(betterIcons, ["get", id], { encoding: "utf8" });
+    if (result.status !== 0 || !result.stdout) {
+      warn(`Could not fetch ${id}. Try: better-icons search ${brand}`);
+      continue;
+    }
+    fs.writeFileSync(out, result.stdout, "utf8");
+    success(`Saved ${path.relative(process.cwd(), out)}`);
+  }
+
+  console.log("");
+  console.log(c.gray("Wire into your reel:"));
+  for (const brand of brands) {
+    const safe = brand.replace(":", "-");
+    console.log(`  ${c.cyan(`<Img src={staticFile("icons/${safe}.svg")} style={{width: 96, height: 96}} />`)}`);
+  }
+  console.log("");
+}
+
+module.exports = { run };

package/cli/index.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+/**
+ * ReelStack CLI — bin entry point.
+ *
+ * Routes:
+ *   reelstack init                    → cli/init.js
+ *   reelstack direction "<brief>"     → cli/direction.js
+ *   reelstack scaffold <flags>        → cli/scaffold.js
+ *   reelstack beats <vo.wav>          → cli/beats.js
+ *   reelstack capture <url>           → cli/capture.js
+ *   reelstack icons <brand>           → cli/icons.js
+ *   reelstack render <id> [flags]     → cli/render.js
+ *   reelstack lint <file> [--critique]→ cli/lint.js
+ *   reelstack preview                 → cli/preview.js
+ *   reelstack update                  → re-verify license, refresh runtime
+ *   reelstack --version
+ *   reelstack --verify                → 0 if license valid, non-zero otherwise
+ */
+const path = require("node:path");
+const { fail, info, success, c } = require("./utils");
+const license = require("./license");
+
+const PKG = require("../package.json");
+
+const HELP = `
+${c.bold("ReelStack")} ${c.gray(`v${PKG.version}`)} — Premium 9:16 Reel OS for Remotion
+
+${c.bold("USAGE")}
+  reelstack <command> [flags]
+
+${c.bold("COMMANDS")}
+  init                          First-time setup, license verify, dep check
+  direction "<brief>"           Get 3 differentiated family picks for a vague brief
+  scaffold --family --preset --name [--vo] [--reference=<preset>]
+                                Scaffold a new reel
+  beats <vo.wav>                Convert voiceover → BEAT constants
+  capture <url>                 Delegate to reel-capture skill
+  icons <brand>                 Pull real brand SVGs via better-icons
+  render <id> [--platform=ig|tiktok|shorts] [--format=mp4,gif] [--bgm=<path>] [--interpolate=60]
+                                Render with platform presets, optional GIF + BGM mix
+  lint <file> [--critique]      Validate motion floors, safe zones, audio lock; --critique = 5-dim radar + Keep/Fix/Quick
+  preview                       Render a 10-second free demo (no license)
+  update                        Re-verify license, refresh runtime
+
+${c.bold("FLAGS")}
+  --version, -v                 Print version and exit
+  --verify                      Exit 0 if license valid, non-zero otherwise
+  --help, -h                    Show this help
+
+${c.bold("DOCS")}
+  ~/.reelstack/docs/buyers-guide.md
+  ~/.reelstack/docs/family-galleries/<family>.md
+  https://reelstack.dev
+`;
+
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
+    console.log(HELP);
+    return;
+  }
+  if (argv.includes("--version") || argv.includes("-v")) {
+    console.log(PKG.version);
+    return;
+  }
+  if (argv.includes("--verify")) {
+    process.exit(license.hasValidLicense() ? 0 : 1);
+  }
+
+  const cmd = argv[0];
+  const rest = argv.slice(1);
+
+  // Commands that DO require a license:
+  const gated = ["scaffold", "beats", "capture", "icons", "render", "lint", "update", "direction"];
+  if (gated.includes(cmd) && !license.hasValidLicense()) {
+    fail("ReelStack license missing or expired. Run `npx @devinilabs/reelstack init` to activate.");
+    process.exit(1);
+  }
+
+  switch (cmd) {
+    case "init":      return require("./init").run(rest);
+    case "direction": return require("./direction").run(rest);
+    case "scaffold":  return require("./scaffold").run(rest);
+    case "beats":     return require("./beats").run(rest);
+    case "capture":   return require("./capture").run(rest);
+    case "icons":     return require("./icons").run(rest);
+    case "render":    return require("./render").run(rest);
+    case "lint":      return require("./lint").run(rest);
+    case "preview":   return require("./preview").run(rest);
+    case "update":    return require("./update").run(rest);
+    default:
+      fail(`Unknown command "${cmd}". Run \`reelstack --help\`.`);
+      process.exit(2);
+  }
+}
+
+main().catch((err) => {
+  fail(err.message || String(err));
+  if (process.env.REELSTACK_DEBUG) console.error(err);
+  process.exit(1);
+});

package/cli/init.js

@@ -0,0 +1,253 @@
+/**
+ * `reelstack init` — first-time setup. The buyer's first contact.
+ *
+ * 1. ASCII banner + welcome.
+ * 2. License prompt + devini.io validate (via license.js).
+ * 3. Dependency check (Node 20+, ffmpeg, whisper-cpp).
+ * 4. Scaffold ~/.reelstack/{families,templates,utils,docs}.
+ * 5. Install skill at ~/.claude/skills/reelstack/.
+ * 6. Install 13 command stubs at ~/.claude/commands/.
+ * 7. If buyer is inside a Remotion project, add @devinilabs/reelstack as a dep
+ *    so scaffolded reels resolve their imports.
+ * 8. Run a smoke `scaffold --family=glass --preset=graphify --name=Demo`.
+ * 9. Print next-steps.
+ */
+const fs = require("node:fs");
+const path = require("node:path");
+const {
+  banner, info, success, fail, warn, c, askYesNo, ensureDir, which,
+  REELSTACK_HOME, CLAUDE_SKILLS_HOME, CLAUDE_COMMANDS_HOME,
+  saveState, getPlatformInstaller,
+} = require("./utils");
+const license = require("./license");
+const bootstrap = require("./bootstrap");
+const smoke = require("./smoke");
+
+const REELSTACK_PKG = path.dirname(__dirname);
+
+function parseFlags(argv) {
+  const flags = {
+    skipSmoke: false,
+    noBootstrap: false,
+    projectName: "reelstack-project",
+  };
+  for (const arg of argv) {
+    if (arg === "--skip-smoke") flags.skipSmoke = true;
+    else if (arg === "--no-bootstrap") flags.noBootstrap = true;
+    else if (arg.startsWith("--name=")) {
+      const value = arg.slice(7);
+      if (value) {
+        const safe = path.basename(value);
+        if (safe && safe !== "." && safe !== "..") flags.projectName = safe;
+      }
+    }
+  }
+  return flags;
+}
+
+function copyTree(src, dst) {
+  if (!fs.existsSync(src)) return;
+  ensureDir(dst);
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, entry.name);
+    const d = path.join(dst, entry.name);
+    if (entry.isDirectory()) copyTree(s, d);
+    else fs.copyFileSync(s, d);
+  }
+}
+
+function checkNode() {
+  const major = Number(process.versions.node.split(".")[0]);
+  if (major < 20) {
+    fail(`Node ${process.versions.node} detected. ReelStack needs Node 20+.`);
+    console.log("");
+    console.log(c.gray("  Install Node 20+ via:"));
+    console.log(`    ${c.cyan("nvm install 20 && nvm use 20")}     # nvm`);
+    console.log(`    ${c.cyan("fnm install 20 && fnm use 20")}     # fnm`);
+    console.log(`    ${c.cyan("https://nodejs.org/")}              # installer`);
+    console.log("");
+    process.exit(1);
+  }
+  success(`Node ${process.versions.node}`);
+  return true;
+}
+
+async function ensureFfmpeg() {
+  if (which("ffmpeg")) {
+    success("ffmpeg found");
+    saveState({ ffmpeg: "ok" });
+    return true;
+  }
+
+  fail("ffmpeg not found.");
+  const installer = getPlatformInstaller(process.platform, "ffmpeg");
+
+  if (installer.kind === "auto") {
+    const yes = await askYesNo(`Run \`${installer.command}\`?`);
+    if (!yes) {
+      console.log("");
+      fail("ffmpeg is required for /reelstack-render and /reelstack-beats.");
+      console.log(c.gray(`  Install later with: ${installer.command}`));
+      console.log(c.gray("  Then re-run: reelstack init"));
+      process.exit(1);
+    }
+    const installResult = installer.install();
+    if (installResult.status !== 0) {
+      fail(`ffmpeg install exited non-zero (status ${installResult.status}). Check the output above.`);
+      process.exit(1);
+    }
+    if (!which("ffmpeg")) {
+      fail("ffmpeg install completed without errors but the binary still isn't on PATH.");
+      process.exit(1);
+    }
+    success("ffmpeg installed");
+    saveState({ ffmpeg: "ok" });
+    return true;
+  }
+
+  // kind === "guide"
+  console.log("");
+  console.log(c.gray("  Install ffmpeg via:"));
+  console.log(c.gray(`    ${installer.command}`));
+  console.log(c.gray("  Then re-run: reelstack init"));
+  console.log("");
+  process.exit(1);
+}
+
+async function ensureWhisper() {
+  if (which("whisper-cli") || which("whisper-cpp")) {
+    success("whisper-cli found");
+    saveState({ whisperCli: "ok" });
+    return true;
+  }
+
+  warn("whisper-cli not found (only required for /reelstack-beats).");
+  const installer = getPlatformInstaller(process.platform, "whisper-cpp");
+
+  if (installer.kind === "auto") {
+    const yes = await askYesNo(`Run \`${installer.command}\`?`);
+    if (yes) {
+      const installResult = installer.install();
+      if (installResult.status !== 0) {
+        warn(`whisper install exited non-zero (status ${installResult.status}). /reelstack-beats will be unavailable.`);
+      } else if (which("whisper-cli") || which("whisper-cpp")) {
+        success("whisper-cli installed");
+        saveState({ whisperCli: "ok" });
+        return true;
+      } else {
+        warn("whisper install completed without errors but the binary still isn't on PATH. /reelstack-beats will be unavailable.");
+      }
+    } else {
+      warn("Skipped. /reelstack-beats will be unavailable until you install whisper-cpp.");
+    }
+  } else {
+    console.log(c.gray(`  Install later with: ${installer.command}`));
+    console.log(c.gray("  /reelstack-beats will be unavailable until then."));
+  }
+
+  saveState({ whisperCli: "missing" });
+  return false;
+}
+
+async function run(argv) {
+  const flags = parseFlags(argv || []);
+  banner();
+  info("Welcome. Let's get ReelStack set up.");
+  console.log("");
+
+  // 1. License
+  const licensed = await license.verifyOrPrompt();
+  if (!licensed) {
+    fail("License required. Visit https://devini.io/reelstack to purchase.");
+    process.exit(1);
+  }
+
+  // 2. Tier 1 — Node hard gate (exits on fail)
+  console.log("");
+  info("Checking dependencies…");
+  checkNode();
+
+  // 3. Tier 2 — System binaries (exits on ffmpeg miss + decline)
+  await ensureFfmpeg();
+  await ensureWhisper();
+
+  // 4. Install ~/.reelstack runtime (preserved from original init)
+  console.log("");
+  info(`Installing ReelStack runtime at ${REELSTACK_HOME}…`);
+  ensureDir(REELSTACK_HOME);
+  for (const sub of ["families", "templates", "utils", "docs", "cli", "reference"]) {
+    copyTree(path.join(REELSTACK_PKG, sub), path.join(REELSTACK_HOME, sub));
+  }
+  fs.copyFileSync(
+    path.join(REELSTACK_PKG, "package.json"),
+    path.join(REELSTACK_HOME, "package.json"),
+  );
+  success("Runtime installed.");
+
+  // 5. Install Claude skill + slash commands (preserved from original init)
+  info(`Installing Claude Code skill at ${path.join(CLAUDE_SKILLS_HOME, "reelstack")}…`);
+  ensureDir(CLAUDE_SKILLS_HOME);
+  copyTree(path.join(REELSTACK_PKG, "skill"), path.join(CLAUDE_SKILLS_HOME, "reelstack"));
+  success("Skill installed.");
+
+  info(`Installing slash commands at ${CLAUDE_COMMANDS_HOME}…`);
+  ensureDir(CLAUDE_COMMANDS_HOME);
+  const cmdsSrc = path.join(REELSTACK_PKG, "skill", "commands");
+  const cmdFiles = fs.readdirSync(cmdsSrc);
+  for (const file of cmdFiles) {
+    fs.copyFileSync(path.join(cmdsSrc, file), path.join(CLAUDE_COMMANDS_HOME, file));
+  }
+  success(`${cmdFiles.length} slash commands installed.`);
+
+  // 6. Tier 3 — Remotion project bootstrap
+  console.log("");
+  const tier3 = await bootstrap.run({
+    noBootstrap: flags.noBootstrap,
+    projectName: flags.projectName,
+  });
+
+  // 7. Tier 4 — Smoke test (only if we have a project to test against)
+  if (tier3.skipped) {
+    saveState({ smokeTest: "skipped-no-project" });
+  } else if (flags.skipSmoke) {
+    saveState({ smokeTest: "skipped" });
+    warn("Smoke test skipped (--skip-smoke).");
+  } else {
+    console.log("");
+    info("Running smoke test…");
+    const result = await smoke.runAll({ projectDir: tier3.projectDir });
+    if (!result.passed) {
+      saveState({ smokeTest: "failed", smokeFailedAt: result.failedAt });
+      fail(`ReelStack is NOT ready — smoke test failed at ${result.failedAt}.`);
+      process.exit(1);
+    }
+    saveState({ smokeTest: "passed" });
+  }
+
+  saveState({ lastInitAt: new Date().toISOString() });
+
+  // 8. Success banner
+  console.log("");
+  if (tier3.skipped) {
+    success("ReelStack CLI installed. Bootstrap a Remotion project to unlock /reelstack-* commands.");
+  } else {
+    success("ReelStack is ready.");
+  }
+  console.log("");
+  console.log(c.gray("  Next:"));
+  if (tier3.skipped) {
+    console.log(`    ${c.gray("Bootstrap a Remotion project, then re-run `reelstack init`.")}`);
+    console.log(`    ${c.cyan("npx create-video@latest --yes --blank my-reels")}`);
+    console.log(`    ${c.cyan("cd my-reels && npx @devinilabs/reelstack init")}`);
+  } else {
+    if (tier3.isNew) {
+      console.log(`    ${c.cyan("cd " + flags.projectName)}`);
+    }
+    console.log(`    ${c.cyan("npm run dev")}                              ${c.gray("# open Remotion Studio")}`);
+    console.log(`    ${c.cyan("/reelstack-glass")}                         ${c.gray("# scaffold a Glass Iridescent reel")}`);
+    console.log(`    ${c.cyan("/reelstack-paper")}                         ${c.gray("# … or any of the other 4 family commands")}`);
+  }
+  console.log("");
+}
+
+module.exports = { run, parseFlags };

package/cli/license.js

@@ -0,0 +1,168 @@
+/**
+ * ReelStack license verification.
+ *
+ * Buyer pays on devini.io/reelstack → license key emailed →
+ * `reelstack init` prompts for the key → POSTs to devini.io validate API
+ * with { license_key, machine_id } → caches to ~/.reelstack/.license
+ * (mode 0600) on success.
+ *
+ * License is only checked at install / `init` / `update` / explicit
+ * `--verify` invocations, but `hasValidLicense()` enforces a 7-day TTL on
+ * the cached `validatedAt` so revocations propagate even when the CLI runs
+ * offline most of the time.
+ *
+ * The validation API enforces a 3-machine cap (rolling 30-day window) by
+ * keying on the random UUID we persist at `~/.reelstack/.machine-id`.
+ */
+const fs = require("node:fs");
+const path = require("node:path");
+const { randomUUID } = require("node:crypto");
+const {
+  REELSTACK_HOME,
+  LICENSE_CACHE,
+  ensureDir,
+  writeFileSafe,
+  fail,
+  info,
+  success,
+  ask,
+  c,
+} = require("./utils");
+
+const VALIDATE_URL =
+  process.env.REELSTACK_VALIDATE_URL ||
+  "https://devini.io/api/license/validate";
+
+const MACHINE_ID_FILE = path.join(REELSTACK_HOME, ".machine-id");
+
+// DEV_OVERRIDE intentionally stripped from published build.
+const DEV_OVERRIDE = () => false;
+
+const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
+
+function readOrCreateMachineId() {
+  try {
+    const raw = fs.readFileSync(MACHINE_ID_FILE, "utf8").trim();
+    if (/^[0-9a-f-]{36}$/i.test(raw)) return raw;
+  } catch {}
+  const id = randomUUID();
+  ensureDir(path.dirname(MACHINE_ID_FILE));
+  fs.writeFileSync(MACHINE_ID_FILE, id, { mode: 0o644 });
+  return id;
+}
+
+async function validateRemote(key) {
+  if (DEV_OVERRIDE()) {
+    return { valid: true, dev: true };
+  }
+  try {
+    const machineId = readOrCreateMachineId();
+    const body = new URLSearchParams({
+      license_key: key,
+      machine_id: machineId,
+    });
+    const res = await fetch(VALIDATE_URL, {
+      method: "POST",
+      headers: { Accept: "application/json" },
+      body,
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      return {
+        valid: false,
+        status: res.status,
+        revoked: !!(data && data.revoked),
+        machine_limit_exceeded: !!(data && data.machine_limit_exceeded),
+        reason: (data && (data.reason || data.error)) || undefined,
+      };
+    }
+    return { valid: !!data.valid, raw: data };
+  } catch (err) {
+    return { valid: false, error: err.message };
+  }
+}
+
+function readCachedLicense() {
+  if (!fs.existsSync(LICENSE_CACHE)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(LICENSE_CACHE, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function cacheLicense(key, raw) {
+  ensureDir(path.dirname(LICENSE_CACHE));
+  writeFileSafe(
+    LICENSE_CACHE,
+    JSON.stringify({ key, validatedAt: Date.now(), raw }, null, 2),
+  );
+  try { fs.chmodSync(LICENSE_CACHE, 0o600); } catch {}
+}
+
+/**
+ * Returns true if a valid cached license exists AND was validated within
+ * the last 7 days. Does NOT re-call the API — that happens only on
+ * `init` / `update`. Use `verifyOrPrompt()` if you need a guaranteed
+ * fresh check.
+ */
+function hasValidLicense() {
+  if (DEV_OVERRIDE()) return true;
+  const cached = readCachedLicense();
+  if (!cached || !cached.key) return false;
+
+  const ageMs = Date.now() - (cached.validatedAt ?? 0);
+  if (ageMs > SEVEN_DAYS_MS) return false; // force re-validation
+
+  return true;
+}
+
+async function verifyOrPrompt() {
+  if (hasValidLicense()) return true;
+  console.log("");
+  info("ReelStack needs a license to continue.");
+  console.log(`  ${c.gray("Don't have one yet? Buy at")} ${c.cyan("https://devini.io/reelstack")}`);
+  console.log("");
+  const key = await ask("Paste your license key:");
+  if (!key) {
+    fail("No license key provided.");
+    return false;
+  }
+  const result = await validateRemote(key);
+  if (!result.valid) {
+    if (result.revoked) {
+      fail(`This license has been revoked${result.reason ? `: ${result.reason}` : ""}. Email abhishek@devini.io if this is a mistake.`);
+      return false;
+    }
+    if (result.machine_limit_exceeded) {
+      fail(`This license is already active on its 3 machines. Email abhishek@devini.io to release a slot for this machine.`);
+      return false;
+    }
+    fail(`License key not recognized${result.error ? `: ${result.error}` : ""}.`);
+    return false;
+  }
+  cacheLicense(key, result.raw);
+  success("License validated and cached at ~/.reelstack/.license.");
+  return true;
+}
+
+async function reverify() {
+  const cached = readCachedLicense();
+  if (!cached || !cached.key) return false;
+  const result = await validateRemote(cached.key);
+  if (!result.valid) return false;
+  cacheLicense(cached.key, result.raw);
+  return true;
+}
+
+module.exports = {
+  hasValidLicense,
+  verifyOrPrompt,
+  reverify,
+  readCachedLicense,
+  cacheLicense,
+  validateRemote,
+  readOrCreateMachineId,
+  VALIDATE_URL,
+  MACHINE_ID_FILE,
+};