@crievo/omni 0.0.0-stage → 0.1.1

package/tools/setup.mjs

@@ -0,0 +1,466 @@
+#!/usr/bin/env node
+/* Prepares a fresh OmniVideo clone and checks whether the machine is ready for
+   the first video. The full walkthrough (with the provider accounts) is in
+   docs/onboarding.md and in the studio's Getting started page
+   (/getting-started), which uses this same check.
+
+     node tools/setup.mjs                  prepares what's missing and checks everything
+     node tools/setup.mjs check [--json]   only checks (the UI reads --json)
+
+   Prepare never overwrites: it creates .env and omnivideo.config.json from the
+   examples only if they don't exist, the empty reference library and sound
+   kit, the project's Python (.venv, with requirements.txt) and the studio
+   dependencies. System programs (Node, Bun, ffmpeg, Python, Chrome) it only
+   checks: installing them is in the guide, step 1. */
+
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  copyFileSync,
+  mkdirSync,
+  readdirSync,
+  chmodSync,
+  statSync,
+} from "node:fs";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { spawnSync } from "node:child_process";
+import { accountsOf, codexBin, loginCommand, loginOf, tildify } from "./lib/agents.mjs";
+import { CODE_ROOT, DATA_ROOT as ROOT } from "./lib/paths.mjs";
+
+const CONFIG = join(ROOT, "omnivideo.config.json");
+const ENV = join(ROOT, ".env");
+const VENV_PY = join(CODE_ROOT, ".venv", "bin", "python");
+
+const args = process.argv.slice(2);
+const sub = args[0] && !args[0].startsWith("--") ? args[0] : "prepare";
+const JSON_OUT = args.includes("--json");
+
+const run = (cmd, a, opts = {}) => {
+  const r = spawnSync(cmd, a, { encoding: "utf8", timeout: 20_000, ...opts });
+  return { ok: r.status === 0, output: `${r.stdout ?? ""}${r.stderr ?? ""}`.trim(), error: r.error };
+};
+const readJson = file => {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+};
+const toPath = p => resolve(ROOT, String(p).replace(/^~(?=\/|$)/, homedir()));
+const cfg = () => readJson(CONFIG);
+
+/* the .env keys that have a value (the value never leaves here) */
+function keysWithValue() {
+  if (!existsSync(ENV)) return new Set();
+  const found = new Set();
+  for (const row of readFileSync(ENV, "utf8").split("\n")) {
+    const m = row.match(/^\s*([A-Z0-9_]+)\s*=\s*(.*)$/);
+    if (m && m[2].trim().replace(/^["']|["']$/g, "")) found.add(m[1]);
+  }
+  return found;
+}
+
+/* the same lookup as render.mjs */
+function findChrome() {
+  const fixed = [
+    process.env.CHROME_PATH,
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+    "/usr/bin/google-chrome",
+    "/usr/bin/chromium",
+  ].filter(Boolean);
+  const found = fixed.find(p => existsSync(p));
+  if (found) return found;
+  const cache = join(homedir(), "Library", "Caches", "ms-playwright");
+  try {
+    if (readdirSync(cache).some(d => d.startsWith("chromium-"))) return cache;
+  } catch {
+    /* no cache */
+  }
+  return null;
+}
+
+const version = (cmd, a = ["--version"]) => {
+  const r = run(cmd, a);
+  return r.ok ? r.output.split("\n")[0] : null;
+};
+
+/* --- check ------------------------------------------------------------------
+   One step per guide section (the id is the `<!-- step: id -->` in docs/onboarding.md).
+   state: ok · missing (blocks the first video) · warning (works, but take a look) */
+function check() {
+  const c = cfg();
+  const env = keysWithValue();
+  const item = (id, title, state, detail) => ({ id, title, state, detail });
+  const steps = [];
+
+  /* 1. the machine */
+  {
+    const node = process.versions.node;
+    const nodeOk = Number(node.split(".")[0]) >= 20;
+    const bun = version("bun");
+    const ffmpeg = version("ffmpeg", ["-version"]);
+    const ffprobe = version("ffprobe", ["-version"]);
+    const py = version("python3");
+    const pyOk =
+      !!py &&
+      (() => {
+        const [, a, b] = py.match(/(\d+)\.(\d+)/) ?? [];
+        return Number(a) === 3 && Number(b) >= 10;
+      })();
+    const chrome = findChrome();
+    steps.push({
+      id: "machine",
+      items: [
+        item(
+          "macos",
+          "macOS",
+          process.platform === "darwin" ? "ok" : "warning",
+          process.platform === "darwin"
+            ? "macOS"
+            : `${process.platform}: o studio roda, mas a agenda de publicação usa o launchd do macOS`,
+        ),
+        item("node", "Node.js 20 ou mais novo", nodeOk ? "ok" : "missing", `v${node}`),
+        item("bun", "Bun", bun ? "ok" : "missing", bun ? `v${bun}` : "não achei o bun no PATH"),
+        item(
+          "ffmpeg",
+          "ffmpeg e ffprobe",
+          ffmpeg && ffprobe ? "ok" : "missing",
+          ffmpeg ? ffmpeg.replace(/ Copyright.*/, "") : "não achei o ffmpeg no PATH",
+        ),
+        item("python", "Python 3.10 ou mais novo", pyOk ? "ok" : "missing", py ?? "não achei o python3 no PATH"),
+        item(
+          "chrome",
+          "Google Chrome (o render do motion usa)",
+          chrome ? "ok" : "missing",
+          chrome ?? "instale o Google Chrome ou defina CHROME_PATH",
+        ),
+        item(
+          "yt-dlp",
+          "yt-dlp (estilo visual a partir de um link)",
+          version("yt-dlp") ? "ok" : "warning",
+          version("yt-dlp")
+            ? `v${version("yt-dlp")}`
+            : "opcional: sem ele, o estilo visual entra só por foto ou arquivo",
+        ),
+      ],
+    });
+  }
+
+  /* 2. the project */
+  {
+    const pyPackages = existsSync(VENV_PY) && run(VENV_PY, ["-c", "import requests, soundfile, numpy"]).ok;
+    steps.push({
+      id: "project",
+      items: [
+        item("config", "omnivideo.config.json", c ? "ok" : "missing", c ? "existe" : "rode node tools/setup.mjs"),
+        item(
+          "env",
+          ".env (chaves, fora do git)",
+          existsSync(ENV) ? "ok" : "missing",
+          existsSync(ENV) ? "existe" : "rode node tools/setup.mjs",
+        ),
+        item(
+          "venv",
+          "Python do projeto (.venv)",
+          pyPackages ? "ok" : "missing",
+          pyPackages ? ".venv com requests, soundfile e numpy" : "rode node tools/setup.mjs",
+        ),
+        item(
+          "studio",
+          "Dependências do studio",
+          existsSync(join(CODE_ROOT, "studio", "node_modules")) ? "ok" : "missing",
+          "studio/node_modules",
+        ),
+      ],
+    });
+  }
+
+  /* 3. the agents (Claude Code, Codex), on the accounts the studio uses (agents.accounts) */
+  {
+    const cfg = readJson(CONFIG) ?? {};
+    const accounts = accountsOf(cfg).filter(a => a.enabled);
+    const cli = version("claude");
+    const usesCodex = accounts.some(a => a.provider === "codex");
+    const codex = usesCodex ? version(codexBin(cfg)) : null;
+    const ready = accounts.filter(a => loginOf(a));
+    steps.push({
+      id: "claude",
+      items: [
+        item("claude-cli", "Claude Code instalado", cli ? "ok" : "missing", cli ?? "não achei o claude no PATH"),
+        ...(usesCodex
+          ? [
+              item(
+                "codex-cli",
+                "Codex instalado",
+                codex ? "ok" : "missing",
+                codex ?? "instale o app do ChatGPT ou o codex no PATH",
+              ),
+            ]
+          : []),
+        item(
+          "claude-login",
+          "Conta de agente com login",
+          ready.length ? "ok" : "missing",
+          ready.length
+            ? `${ready.length} de ${accounts.length} conta(s) com login`
+            : `rode ${accounts[0] ? loginCommand(accounts[0], cfg) : "CLAUDE_CONFIG_DIR=~/.claude-personal claude auth login"}`,
+        ),
+        ...accounts
+          .filter(a => !loginOf(a) && a !== accounts[0])
+          .map(a => item(`login-${a.id}`, `Sem login em ${tildify(a.dir)}`, "warning", `rode ${loginCommand(a, cfg)}`)),
+      ],
+    });
+  }
+
+  /* 4. the voice: a provider key and a voice with that provider's id */
+  {
+    const provs = [
+      ["fish", "FISH_API_KEY", "Fish Audio"],
+      ["cartesia", "CARTESIA_API_KEY", "Cartesia"],
+      ["elevenlabs", "ELEVENLABS_API_KEY", "ElevenLabs"],
+    ];
+    const withKey = provs.filter(([, k]) => env.has(k));
+    const profiles = c?.voice?.profiles ?? [];
+    const readyVoice = profiles.find(p => withKey.some(([id]) => p[id]));
+    steps.push({
+      id: "voice",
+      items: [
+        item(
+          "voice-key",
+          "Chave de um provider de voz",
+          withKey.length ? "ok" : "missing",
+          withKey.length
+            ? withKey.map(([, , name]) => name).join(", ")
+            : "nenhuma chave da Fish, Cartesia ou ElevenLabs no .env",
+        ),
+        item(
+          "voice-profile",
+          "Uma voz clonada no studio",
+          readyVoice ? "ok" : "missing",
+          readyVoice
+            ? `${readyVoice.name}`
+            : profiles.length
+              ? "a voz criada não tem o ID do provider que tem chave"
+              : "nenhuma voz em Configurações → Voz",
+        ),
+      ],
+    });
+  }
+
+  /* 5. the style: at least one reference in the library */
+  {
+    const dir = c ? toPath(c.references?.dir ?? "../referencias") : null;
+    let refs = [];
+    try {
+      refs = readdirSync(dir).filter(d => !d.startsWith(".") && statSync(join(dir, d)).isDirectory());
+    } catch {
+      /* no dir */
+    }
+    steps.push({
+      id: "reference",
+      items: [
+        item(
+          "reference",
+          "Um estilo visual",
+          refs.length ? "ok" : "missing",
+          refs.length
+            ? `${refs.length} na biblioteca de estilos visuais (${dir})`
+            : `a biblioteca de estilos visuais está vazia${dir ? ` (${dir})` : ""}`,
+        ),
+      ],
+    });
+  }
+
+  /* 6. sound: the kit may start empty, but then Claude searches Epidemic through Chrome */
+  {
+    const kit = readJson(join(ROOT, "kit", "sfx", "kit.json")) ?? {};
+    const n = Object.keys(kit).length;
+    /* any Claude account that already connected the extension */
+    const ext = accountsOf(readJson(CONFIG) ?? {})
+      .filter(a => a.provider === "claude")
+      .map(a => readJson(join(a.dir, ".claude.json")))
+      .some(c => c?.hasCompletedClaudeInChromeOnboarding || c?.cachedChromeExtensionInstalled);
+    steps.push({
+      id: "sound",
+      items: [
+        item(
+          "kit",
+          "Kit de efeitos",
+          n ? "ok" : "warning",
+          n ? `${n} efeitos` : "vazio: a primeira composição busca os efeitos na Epidemic Sound",
+        ),
+        item(
+          "chrome-ext",
+          "Claude in Chrome (para buscar efeitos)",
+          ext ? "ok" : n ? "warning" : "missing",
+          ext ? "extensão conectada" : "instale a extensão Claude in Chrome e entre na Epidemic Sound no Chrome",
+        ),
+      ],
+    });
+  }
+
+  /* 7. the first video */
+  {
+    let done = null;
+    try {
+      for (const v of readdirSync(join(ROOT, "videos"))) {
+        const exp = join(ROOT, "videos", v, "export");
+        if (existsSync(exp) && readdirSync(exp).some(a => a.endsWith(".mp4"))) {
+          done = v;
+          break;
+        }
+      }
+    } catch {
+      /* no videos/ */
+    }
+    steps.push({
+      id: "first-video",
+      items: [
+        item("video", "Um vídeo exportado", done ? "ok" : "missing", done ?? "nenhum ainda: crie em Criar vídeo"),
+      ],
+    });
+  }
+
+  /* 8. publish (optional) */
+  {
+    const has = (...ks) => ks.every(k => env.has(k));
+    const cloudflared = version("cloudflared");
+    steps.push({
+      id: "publish",
+      optional: true,
+      items: [
+        item(
+          "cloudflared",
+          "cloudflared (o Instagram busca o vídeo por ele)",
+          cloudflared ? "ok" : "warning",
+          cloudflared ? cloudflared.split(" (")[0] : "opcional: só para publicar no Instagram",
+        ),
+        item(
+          "youtube",
+          "YouTube",
+          has("YOUTUBE_CLIENT_ID", "YOUTUBE_CLIENT_SECRET", "YOUTUBE_REFRESH_TOKEN") ? "ok" : "warning",
+          has("YOUTUBE_REFRESH_TOKEN") ? "conectado" : "opcional: não conectado",
+        ),
+        item(
+          "instagram",
+          "Instagram",
+          has("INSTAGRAM_TOKEN", "INSTAGRAM_USER_ID") ? "ok" : "warning",
+          has("INSTAGRAM_TOKEN") ? "conectado" : "opcional: não conectado",
+        ),
+        item(
+          "tiktok",
+          "TikTok",
+          has("TIKTOK_CLIENT_KEY", "TIKTOK_ACCESS_TOKEN") ? "ok" : "warning",
+          has("TIKTOK_ACCESS_TOKEN") ? "conectado" : "opcional: não conectado",
+        ),
+      ],
+    });
+  }
+
+  for (const s of steps) {
+    s.state = s.items.some(i => i.state === "missing")
+      ? "missing"
+      : s.items.some(i => i.state === "warning")
+        ? "warning"
+        : "ok";
+  }
+  /* ready for the first video: everything before it with nothing missing */
+  const upTo = steps.findIndex(s => s.id === "first-video");
+  const ready = steps.slice(0, upTo).every(s => s.state !== "missing");
+  return { ready, steps };
+}
+
+/* --- prepare ------------------------------------------------------------------------ */
+function prepare() {
+  const done = [];
+  if (!existsSync(ENV)) {
+    copyFileSync(join(CODE_ROOT, ".env.example"), ENV);
+    chmodSync(ENV, 0o600);
+    done.push("criei o .env a partir do .env.example (as chaves entram pela tela)");
+  }
+  if (!existsSync(CONFIG)) {
+    copyFileSync(join(CODE_ROOT, "omnivideo.config.example.json"), CONFIG);
+    done.push("criei o omnivideo.config.json a partir do exemplo");
+  }
+  const c = cfg();
+  const library = toPath(c?.references?.dir ?? "../referencias");
+  if (!existsSync(library)) {
+    mkdirSync(library, { recursive: true });
+    done.push(`criei a biblioteca de estilos visuais em ${library}`);
+  }
+  const kit = join(ROOT, "kit", "sfx");
+  if (!existsSync(join(kit, "kit.json"))) {
+    mkdirSync(kit, { recursive: true });
+    writeFileSync(join(kit, "kit.json"), "{}\n");
+    done.push("criei o kit de efeitos vazio (kit/sfx/kit.json)");
+  }
+  mkdirSync(join(ROOT, "videos"), { recursive: true });
+
+  if (!existsSync(VENV_PY)) {
+    if (!version("python3")) done.push("✗ sem python3: instale (passo 1 do guia) e rode de novo");
+    else {
+      process.stdout.write("criando o Python do projeto (.venv)… ");
+      const r = run("python3", ["-m", "venv", join(CODE_ROOT, ".venv")], { timeout: 120_000 });
+      console.log(r.ok ? "ok" : `falhou\n${r.output}`);
+    }
+  }
+  if (existsSync(VENV_PY) && !run(VENV_PY, ["-c", "import requests, soundfile, numpy"]).ok) {
+    process.stdout.write("instalando requests, soundfile e numpy… ");
+    const r = run(VENV_PY, ["-m", "pip", "install", "-q", "-r", join(CODE_ROOT, "requirements.txt")], {
+      timeout: 600_000,
+    });
+    console.log(r.ok ? "ok" : `falhou\n${r.output}`);
+  }
+  if (!existsSync(join(CODE_ROOT, "studio", "node_modules"))) {
+    if (!version("bun")) done.push("✗ sem bun: instale (passo 1 do guia) e rode de novo");
+    else {
+      process.stdout.write("instalando as dependências do studio (bun install)… ");
+      const r = run("bun", ["install", "--frozen-lockfile"], { cwd: join(CODE_ROOT, "studio"), timeout: 600_000 });
+      console.log(r.ok ? "ok" : `falhou\n${r.output}`);
+    }
+  }
+  for (const f of done) console.log(f.startsWith("✗") ? f : `• ${f}`);
+  if (done.length) console.log("");
+}
+
+/* --- output --------------------------------------------------------------------------- */
+const TITLES = {
+  machine: "1. Ferramentas da máquina",
+  project: "2. O projeto",
+  claude: "3. Claude Code",
+  voice: "4. Voz",
+  reference: "5. Estilo visual",
+  sound: "6. Efeitos sonoros",
+  "first-video": "7. Primeiro vídeo",
+  publish: "8. Publicar (opcional)",
+};
+const MARK = { ok: "✓", missing: "✗", warning: "!" };
+
+function print(r) {
+  for (const s of r.steps) {
+    console.log(`${MARK[s.state]} ${TITLES[s.id] ?? s.id}`);
+    for (const i of s.items) console.log(`    ${MARK[i.state]} ${i.title}: ${i.detail}`);
+  }
+  console.log("");
+  console.log(
+    r.ready
+      ? "Pronto para o primeiro vídeo: cd studio && bun start, e abra http://127.0.0.1:5432"
+      : "Ainda falta algo (✗). O passo a passo está em docs/onboarding.md e na tela Primeiros passos do studio (http://127.0.0.1:5432/getting-started).",
+  );
+}
+
+if (sub === "check") {
+  const r = check();
+  if (JSON_OUT) console.log(JSON.stringify(r));
+  else print(r);
+} else if (sub === "prepare") {
+  prepare();
+  print(check());
+} else {
+  console.error("uso: node tools/setup.mjs [check [--json]]");
+  process.exit(2);
+}

package/tools/skills-release.mjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+/* ============================================================================
+   A release of the skills (docs/specs/phase-2-plugin-cli.md, step 3): builds it from .claude/skills
+   (tools/lib/skills-release.mjs) and publishes it to the studio's registry (cloud/studio/src/skills.mjs).
+   Meant for CI on every merge into main; runs the same here.
+
+     node tools/skills-release.mjs build [--out <pasta>] [--cli "<comando>"]
+         writes <pasta>/release.json (what the registry stores) and <pasta>/plugin/ (the whole public
+         plugin: manifest, marketplace, hook, MCP and the skills' headers); default <pasta>: .release/skills.
+         --cli is the command the plugin and the served skills call (default: npx -y @crievo/omni, or
+         OMNI_CLI_COMMAND), e.g. "node /caminho/bin/omni.mjs" to try it before publishing
+     node tools/skills-release.mjs publish [--out <pasta>]
+         sends <pasta>/release.json to <cloud.studio_url>/skills/publish with SKILLS_PUBLISH_SECRET
+         (the environment, else .env)
+   ============================================================================ */
+
+import { mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { CLI_COMMAND } from "./lib/cli.mjs";
+import { buildRelease, pluginFiles } from "./lib/skills-release.mjs";
+import { CODE_ROOT } from "./lib/paths.mjs";
+import { cloudSettings, env } from "./platforms.mjs";
+
+const args = process.argv.slice(2);
+const flag = (/** @type {string} */ name) => {
+  const i = args.indexOf(`--${name}`);
+  return i < 0 ? undefined : (args[i + 1] ?? "");
+};
+const fail = (/** @type {string} */ m) => {
+  console.error(`erro: ${m}`);
+  process.exit(1);
+};
+
+const SKILLS = join(CODE_ROOT, ".claude", "skills");
+const out = resolve(flag("out") ?? join(CODE_ROOT, ".release", "skills"));
+
+/** every skill folder, its text files by path (SKILL.md and the siblings it reads) */
+function readSkills() {
+  /** @param {string} dir @param {string} [prefix] @returns {[string, string][]} */
+  const walk = (dir, prefix = "") =>
+    readdirSync(dir, { withFileTypes: true }).flatMap(e =>
+      e.isDirectory()
+        ? walk(join(dir, e.name), `${prefix}${e.name}/`)
+        : /\.(md|txt|json|html|css|js|mjs|py|sh)$/.test(e.name)
+          ? [[`${prefix}${e.name}`, readFileSync(join(dir, e.name), "utf8")]]
+          : [],
+    );
+  return readdirSync(SKILLS, { withFileTypes: true })
+    .filter(e => e.isDirectory())
+    .map(e => ({ name: e.name, files: Object.fromEntries(walk(join(SKILLS, e.name))) }));
+}
+
+const [cmd] = args;
+
+if (cmd === "build") {
+  const cli = flag("cli") || CLI_COMMAND;
+  const release = buildRelease(readSkills(), { run: `${cli} run`, skill: `${cli} skill` });
+  rmSync(out, { recursive: true, force: true });
+  mkdirSync(out, { recursive: true });
+  const { headers: _headers, warnings, ...stored } = release;
+  writeFileSync(join(out, "release.json"), JSON.stringify(stored));
+  for (const [path, text] of Object.entries(pluginFiles(release, { cli }))) {
+    mkdirSync(dirname(join(out, "plugin", path)), { recursive: true });
+    writeFileSync(join(out, "plugin", path), text);
+  }
+  console.log(`versão ${release.version} · ${release.skills.length} skills em ${out}`);
+  for (const s of release.skills)
+    console.log(
+      `  ${s.name.padEnd(14)} ${String(s.size).padStart(6)} caracteres${s.parts.length > 1 ? ` · ${s.parts.length} partes` : ""}`,
+    );
+  for (const w of warnings) console.error(`aviso: ${w}`);
+} else if (cmd === "publish") {
+  const secret = process.env.SKILLS_PUBLISH_SECRET || env("SKILLS_PUBLISH_SECRET");
+  if (!secret) fail("falta SKILLS_PUBLISH_SECRET (no ambiente ou no .env)");
+  const url = cloudSettings().studio.url;
+  if (!url) fail("falta cloud.studio_url no omnivideo.config.json");
+  let body;
+  try {
+    body = readFileSync(join(out, "release.json"), "utf8");
+  } catch {
+    fail(`não achei ${join(out, "release.json")}: rode build antes`);
+  }
+  const r = await fetch(`${url}/skills/publish`, {
+    method: "POST",
+    headers: { "content-type": "application/json", "x-publish-secret": secret },
+    body,
+  }).catch(e => fail(`o studio não respondeu: ${e.message}`));
+  const j = /** @type {any} */ (await r.json().catch(() => ({})));
+  if (!r.ok) fail(j.error ?? `o studio respondeu ${r.status}`);
+  console.log(`publicada a versão ${j.version}: ${j.added} skills novas no registro`);
+} else {
+  fail('uso: node tools/skills-release.mjs build [--out <pasta>] [--cli "<comando>"] | publish [--out <pasta>]');
+}