@crievo/omni 0.0.0-stage → 0.1.1

package/tools/narrate.mjs

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+/* ============================================================================
+   Parallel narration (stage 4): one fork per scene writes that scene's lines,
+   all at once.
+
+     node tools/narrate.mjs plan  videos/<slug> [--only c02,c05] [--all] [--json]
+         which scenes, the model and effort, and each fork's prompt. Each scene
+         is handed out once (tools/lib/fanout.mjs): a second plan launches
+         nothing for a scene still running.
+     node tools/narrate.mjs apply videos/<slug> cNN
+         merges narration/<id>.json into scenes.json, under the scenes lock.
+     node tools/narrate.mjs check videos/<slug>
+         the stage's gate over the whole video, after the last fork: every
+         scene with lines, every beat tied to a word that exists, no line over
+         22 words. Exit 1 with the problems; the total against 60 s (9:16) is a
+         warning.
+
+   A scene fork writes only narration/<id>.json:
+
+     { "lines": [ { "id": "c03f1", "text": "…", "instruct"?: "…" }, … ],
+       "enters_with": { "<beat element>": "c03f1:palavra", … } }
+
+   and calls `apply`, the only writer of scenes.json while the forks run. A line
+   that keeps its id and text keeps its voice (wav, dur, hash…); a changed text
+   changes the hash, and `omnivideo.py voice` redoes only that line.
+   ============================================================================ */
+
+import { readFileSync, writeFileSync, existsSync, renameSync } from "node:fs";
+import { join, resolve, relative } from "node:path";
+import { plan as fanout, agentModel, waves as split, printPlan, withScenesLock } from "./lib/fanout.mjs";
+import { resolveTime } from "./timing.mjs";
+import { isNarrated } from "./lib/narration.mjs";
+import { DATA_ROOT as ROOT } from "./lib/paths.mjs";
+
+const CFG = JSON.parse(readFileSync(join(ROOT, "omnivideo.config.json"), "utf8"));
+const MAX_WORDS = 22;
+/* the cloned voice as measured, at 1.0× (skill av-narration, Line rules) */
+const WORDS_PER_S = 2.2;
+
+const [cmd, target, ...rest] = process.argv.slice(2);
+const flag = n => rest.includes(`--${n}`);
+const opt = n => {
+  const i = rest.indexOf(`--${n}`);
+  return i < 0 ? null : rest[i + 1];
+};
+const usage = () => {
+  console.error(
+    "uso: node tools/narrate.mjs plan videos/<slug> [--only c02,c05] [--all] [--json]\n" +
+      "     node tools/narrate.mjs apply videos/<slug> cNN\n" +
+      "     node tools/narrate.mjs check videos/<slug>",
+  );
+  process.exit(2);
+};
+if (!cmd || !target) usage();
+const dir = resolve(target);
+const slug = relative(ROOT, dir);
+if (!existsSync(join(dir, "scenes.json"))) {
+  console.error(`erro: falta ${join(dir, "scenes.json")}`);
+  process.exit(2);
+}
+const readScenes = () => JSON.parse(readFileSync(join(dir, "scenes.json"), "utf8"));
+const fail = msg => {
+  console.error(`erro: ${msg}`);
+  process.exit(1);
+};
+const wordCount = text =>
+  String(text ?? "")
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean).length;
+
+/* a ref checked against the scene's lines: the line exists and so does the word */
+function refProblem(scene, ref) {
+  const probe = { ...scene, lines: (scene.lines ?? []).map(l => ({ id: l.id, text: l.text, start: 0, end: 1 })) };
+  try {
+    resolveTime(probe, ref);
+    return null;
+  } catch (e) {
+    return e.message;
+  }
+}
+
+/* ---------- plan ---------------------------------------------------------- */
+
+async function plan() {
+  if (!isNarrated(dir)) fail("este vídeo é sem narração e voz (content.json): não há narração a escrever");
+  const video = readScenes();
+  const ids = video.scenes.map(s => s.id);
+  const only = opt("only")?.split(",").filter(Boolean) ?? null;
+  if (only) {
+    const outside = only.filter(id => !ids.includes(id));
+    if (outside.length) fail(`não são cenas do scenes.json: ${outside.join(", ")}`);
+  }
+  const noBeats = video.scenes.filter(s => !s.beats?.length).map(s => s.id);
+  if (noBeats.length) fail(`cenas sem beats (componha antes, etapa 3): ${noBeats.join(", ")}`);
+  const wanted = only ?? (flag("all") ? ids : video.scenes.filter(s => !s.lines?.length).map(s => s.id));
+  const stage = CFG.models?.stages?.["av-narration"] ?? { model: "haiku", effort: "high" };
+  const parallel = Math.max(1, CFG.narration?.parallel ?? CFG.motion?.compose?.parallel ?? 8);
+  const model = agentModel(stage.model),
+    effort = stage.effort ?? "high";
+  if (!wanted.length) {
+    if (flag("json")) console.log(JSON.stringify({ video: slug, run: null, waves: [], busy: [] }, null, 2));
+    else console.log(`nada a narrar: toda cena já tem falas. Próximo: node tools/narrate.mjs check ${slug}`);
+    return;
+  }
+  const { run, planned, busy } = await fanout(dir, "narration", wanted);
+  const prompt = id =>
+    `Você é um fork da skill av-narration. Leia .claude/skills/av-narration/SKILL.md e siga-a ` +
+    `com este pedido: ${slug} narrar ${id} (paralelo, rodada ${run}). Termine com o relatório curto que a skill pede.`;
+  const ws = split(planned, parallel);
+  if (flag("json")) {
+    console.log(
+      JSON.stringify(
+        {
+          video: slug,
+          run,
+          model,
+          effort,
+          busy,
+          waves: ws.map(w => w.map(id => ({ scene: id, description: `narrar ${id}`, prompt: prompt(id) }))),
+        },
+        null,
+        2,
+      ),
+    );
+    return;
+  }
+  printPlan({
+    title: `narração em paralelo · ${planned.length} cena(s) nesta rodada · até ${parallel} por vez · modelo ${model}, esforço ${effort}`,
+    run,
+    waves: ws,
+    model,
+    effort,
+    prompt,
+    busy,
+    after: `Depois da última onda: node tools/narrate.mjs check ${slug} (o gate da etapa).`,
+  });
+}
+
+/* ---------- apply --------------------------------------------------------- */
+
+function writeAtomic(file, text) {
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, text);
+  renameSync(tmp, file);
+}
+
+async function apply() {
+  const id = rest[0];
+  if (!id) usage();
+  const file = join(dir, "narration", `${id}.json`);
+  if (!existsSync(file)) fail(`falta ${relative(ROOT, file)}`);
+  let p;
+  try {
+    p = JSON.parse(readFileSync(file, "utf8"));
+  } catch (e) {
+    fail(`${relative(ROOT, file)} não é JSON válido: ${e.message}`);
+  }
+  await withScenesLock(dir, () => {
+    const video = readScenes();
+    const scene = video.scenes.find(s => s.id === id);
+    if (!scene) throw new Error(`${id} não existe em scenes.json`);
+    const errors = [],
+      warnings = [];
+    if (!Array.isArray(p.lines) || !p.lines.length) errors.push("lines precisa ser uma lista não vazia");
+    const seen = new Set();
+    for (const l of p.lines ?? []) {
+      if (!l?.id || !new RegExp(`^${id}f\\d+$`).test(l.id))
+        errors.push(`id de fala inválido: ${l?.id} (use ${id}f1, ${id}f2…)`);
+      else if (seen.has(l.id)) errors.push(`fala repetida: ${l.id}`);
+      seen.add(l?.id);
+      if (!String(l?.text ?? "").trim()) errors.push(`${l?.id}: texto vazio`);
+      else if (wordCount(l.text) > MAX_WORDS)
+        errors.push(`${l.id}: ${wordCount(l.text)} palavras (máximo ${MAX_WORDS})`);
+    }
+    const ew = p.enters_with ?? {};
+    const elements = new Set((scene.beats ?? []).map(b => b.element));
+    for (const el of Object.keys(ew))
+      if (!elements.has(el)) errors.push(`enters_with de um beat que não existe: ${el}`);
+    if (errors.length) throw new Error(errors.map(e => `${id}: ${e}`).join("\nerro: "));
+
+    /* a line that keeps its id keeps what the voice stage wrote on it */
+    const old = Object.fromEntries((scene.lines ?? []).map(l => [l.id, l]));
+    scene.lines = p.lines.map(l => {
+      const prev = old[l.id];
+      const next = { id: l.id, text: l.text.trim(), ...(l.instruct ? { instruct: l.instruct } : {}) };
+      return prev ? { ...prev, ...next, ...(l.instruct ? {} : { instruct: undefined }) } : next;
+    });
+    for (const l of scene.lines) if (l.instruct === undefined) delete l.instruct;
+    for (const b of scene.beats ?? []) {
+      if (ew[b.element] != null) b.enters_with = ew[b.element];
+      if (b.enters_with == null) warnings.push(`beat ${b.element} sem enters_with`);
+      else {
+        const problem = refProblem(scene, b.enters_with);
+        if (problem) errors.push(`beat ${b.element}: ${problem}`);
+      }
+    }
+    if (errors.length) throw new Error(errors.map(e => `${id}: ${e}`).join("\nerro: "));
+    writeAtomic(join(dir, "scenes.json"), JSON.stringify(video, null, 2) + "\n");
+    const words = scene.lines.reduce((n, l) => n + wordCount(l.text), 0);
+    console.log(
+      `${id} · ${scene.lines.length} fala(s), ${words} palavras · ${Object.keys(ew).length} beat(s) ligados → scenes.json`,
+    );
+    warnings.forEach(w => console.log(`aviso: ${id}: ${w}`));
+  });
+}
+
+/* ---------- check --------------------------------------------------------- */
+
+function check() {
+  const video = readScenes();
+  const problems = [],
+    notes = [];
+  let words = 0;
+  for (const s of video.scenes) {
+    if (!s.lines?.length) {
+      problems.push(`${s.id}: sem falas`);
+      continue;
+    }
+    for (const l of s.lines) {
+      words += wordCount(l.text);
+      if (!String(l.text ?? "").trim()) problems.push(`${l.id}: texto vazio`);
+      else if (wordCount(l.text) > MAX_WORDS)
+        problems.push(`${l.id}: ${wordCount(l.text)} palavras (máximo ${MAX_WORDS})`);
+    }
+    for (const b of s.beats ?? []) {
+      if (b.enters_with == null) problems.push(`${s.id}: beat ${b.element} sem enters_with`);
+      else {
+        const problem = refProblem(s, b.enters_with);
+        if (problem) problems.push(`${s.id}: beat ${b.element}: ${problem}`);
+      }
+    }
+  }
+  const speed = Number(video.voice?.speed ?? CFG.voice?.fish?.speed ?? 1) || 1;
+  const est = words / (WORDS_PER_S * speed);
+  const portrait = (video.format?.h ?? 1920) > (video.format?.w ?? 1080);
+  notes.push(`${words} palavras ≈ ${est.toFixed(0)} s de voz (${WORDS_PER_S} palavras/s × velocidade ${speed})`);
+  /* a warning, not a failure: the duration in script.md may ask for more, and 2.2 words/s is the slow end */
+  if (portrait && est > 60)
+    notes.push(
+      `aviso: ≈ ${est.toFixed(0)} s de voz passa de 60 s (9:16): confira a duração pedida no script.md; se passou, corte falas, não cenas`,
+    );
+  notes.forEach(n => console.log(n));
+  if (problems.length) {
+    console.error(`erro: o gate da narração não passa:\n  ${problems.join("\n  ")}`);
+    process.exit(1);
+  }
+  console.log("narração ok: toda cena com falas e todo beat ligado a uma palavra que existe");
+}
+
+if (cmd === "plan" || cmd === "apply")
+  await (cmd === "plan" ? plan() : apply()).catch(e => {
+    console.error(`erro: ${e.message}`);
+    process.exit(1);
+  });
+else if (cmd === "check") check();
+else usage();

package/tools/omni.mjs

@@ -0,0 +1,298 @@
+#!/usr/bin/env node
+/* ============================================================================
+   The `omni` CLI (docs/specs/phase-2-plugin-cli.md): `npx -y @crievo/omni …` once published (bin/omni.mjs
+   settles the workspace and calls main), `node tools/omni.mjs …` in this repo. The plugin calls it from its
+   hook, its MCP server and its skills' `!` lines, so the user needs no terminal. The login is OAuth with PKCE
+   in the browser (tools/lib/oauth-client.mjs); the tokens live in the macOS Keychain, never in .env.
+
+     omni up [--hook]            readies this machine: workspace, app, Python, login, studio service
+                                 (tools/lib/up.mjs); --hook prints one line and never waits on the login
+     omni login [--name <nome>]  enters through the browser: approve, and this computer is in
+     omni status [--json]        the account, the plan, the credits and this computer
+     omni logout                 signs this computer out in the cloud and here
+     omni allow [--yes]          the Claude Code permission rules the skills need (asks first)
+     omni setup                  login, the rules and up, for whoever starts from a terminal
+     omni doctor                 the system programs and keys (tools/setup.mjs check)
+     omni skill <nome> [--v <versão>] [--part i/n]
+                                 one part of a skill's body from the registry (tools/lib/skill-client.mjs)
+     omni run <ferramenta> [args…]
+                                 a pipeline tool against the workspace, what the served skills call
+     omni mcp                    the plugin's MCP server over stdio (tools/lib/mcp-server.mjs)
+   ============================================================================ */
+
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { hostname } from "node:os";
+import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { allowSkillRules, missingRules, settingsFile } from "./lib/claude-settings.mjs";
+import { CLI_COMMAND, STUDIO_URL } from "./lib/cli.mjs";
+import { serveMcp } from "./lib/mcp-server.mjs";
+import { accessToken, login, logout, readTokens } from "./lib/oauth-client.mjs";
+import { CODE_ROOT, DATA_ROOT, isMainModule } from "./lib/paths.mjs";
+import { service } from "./lib/service.mjs";
+import { skillText } from "./lib/skill-client.mjs";
+import { up } from "./lib/up.mjs";
+import { cloudSettings } from "./platforms.mjs";
+
+const fail = (/** @type {string} */ m) => {
+  console.error(`erro: ${m}`);
+  process.exit(1);
+};
+
+const studioUrl = () => cloudSettings().studio.url || STUDIO_URL;
+const deviceName = () => hostname().replace(/\.local$/, "");
+const version = () => {
+  try {
+    return JSON.parse(readFileSync(join(CODE_ROOT, "package.json"), "utf8")).version ?? "dev";
+  } catch {
+    return "dev";
+  }
+};
+
+/** the account as the studio sees it, or why not  @param {string} url */
+async function account(url) {
+  const token = await accessToken(url);
+  if (!token) return { logged_in: false };
+  const r = await fetch(`${url}/account`, { headers: { authorization: `Bearer ${token}` } });
+  const a = /** @type {any} */ (await r.json().catch(() => ({})));
+  if (!r.ok) throw new Error(a.error ?? `o studio respondeu ${r.status}`);
+  return { logged_in: true, ...a };
+}
+
+/** @param {any} a */
+const planText = a =>
+  a.active
+    ? `${a.plan} (ativo)`
+    : a.plan
+      ? `${a.plan} (${a.status === "past_due" ? "pagamento atrasado" : "cancelado"})`
+      : "sem plano";
+
+/** one paragraph for the model: what works and what is missing  @param {string} url */
+async function statusText(url) {
+  const lines = [];
+  try {
+    const a = await account(url);
+    lines.push(
+      a.logged_in
+        ? `Logado como ${a.email} neste computador (${a.device?.name}); plano ${planText(a)}; ${a.credits} créditos.`
+        : "Este computador não está logado no OmniVideo: chame omni_login.",
+    );
+  } catch (e) {
+    lines.push(`O studio do OmniVideo não respondeu: ${/** @type {Error} */ (e).message}.`);
+  }
+  const s = service();
+  lines.push(
+    s.loaded
+      ? "O studio deste computador está ligado e atende o studio hospedado."
+      : "O studio deste computador está desligado.",
+  );
+  const rules = missingRules();
+  lines.push(
+    rules.length
+      ? "As skills do OmniVideo ainda não têm permissão para rodar sem pedir aprovação: pergunte ao usuário se pode liberar e, com um sim, chame omni_allow_skills."
+      : "As skills do OmniVideo têm permissão para rodar.",
+  );
+  lines.push(`Studio hospedado: ${url}`);
+  return lines.join("\n");
+}
+
+/** the plugin's MCP tools  @param {string} url */
+const mcpTools = url => [
+  {
+    name: "omni_status",
+    description:
+      "Estado do OmniVideo neste computador: login, plano, créditos, o studio local e as permissões das skills. Use quando o usuário perguntar do OmniVideo, antes de começar um vídeo, ou quando uma skill do OmniVideo falhar.",
+    inputSchema: { type: "object", properties: {} },
+    run: () => statusText(url),
+  },
+  {
+    name: "omni_login",
+    description:
+      "Abre o navegador para o usuário entrar no OmniVideo e aprovar este computador, e espera ele terminar (até 10 minutos). Use quando omni_status disser que falta entrar.",
+    inputSchema: { type: "object", properties: {} },
+    run: async () => {
+      const t = await login(url, { deviceName: deviceName() });
+      return `Pronto: "${t.device_name}" entrou no OmniVideo. O studio deste computador passa a usar o login em até 30 segundos.`;
+    },
+  },
+  {
+    name: "omni_allow_skills",
+    description:
+      "Grava nas settings do Claude Code as regras que deixam as skills do OmniVideo buscar o próprio texto e rodar as ferramentas do pipeline sem pedir aprovação a cada uso. SÓ chame depois de perguntar ao usuário, em português, e ele responder que sim.",
+    inputSchema: { type: "object", properties: {} },
+    run: () => {
+      const added = allowSkillRules();
+      return added.length
+        ? `Regras gravadas em ${settingsFile()}:\n${added.map(r => `- ${r}`).join("\n")}\nValem a partir da próxima skill.`
+        : "As regras já estavam gravadas.";
+    },
+  },
+  {
+    name: "omni_skill",
+    description:
+      "O texto de uma skill do OmniVideo, direto do registro. Use só quando a skill apareceu como um comando em vez de instruções (shell das skills desligado).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "o nome da skill, como av-motion" },
+        part: { type: "integer", description: "a parte, quando a skill tem mais de uma (padrão 1)" },
+        version: { type: "string", description: "a versão que o cabeçalho da skill indica" },
+      },
+      required: ["name"],
+    },
+    run: (/** @type {{ name: string, part?: number, version?: string }} */ a) =>
+      skillText({
+        studioUrl: url,
+        name: a.name,
+        version: a.version,
+        part: a.part ?? 1,
+        codeRoot: CODE_ROOT,
+        token: () => accessToken(url),
+      }),
+  },
+  {
+    name: "omni_studio",
+    description: "O endereço do studio hospedado do OmniVideo, ou de um vídeo nele, para mandar ao usuário.",
+    inputSchema: {
+      type: "object",
+      properties: { slug: { type: "string", description: "a pasta do vídeo, como 2026-10-18-tema" } },
+    },
+    run: (/** @type {{ slug?: string }} */ a) => (a.slug ? `${url}/videos/${encodeURIComponent(a.slug)}` : url),
+  },
+];
+
+/** asks yes or no on the terminal; no terminal is a no  @param {string} question */
+async function confirm(question) {
+  if (!process.stdin.isTTY) return false;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = (await rl.question(`${question} [s/N] `)).trim().toLowerCase();
+  rl.close();
+  return answer === "s" || answer === "sim" || answer === "y";
+}
+
+/** @param {string[]} args */
+export async function main(args) {
+  const flag = (/** @type {string} */ name) => {
+    const i = args.indexOf(`--${name}`);
+    return i < 0 ? undefined : (args[i + 1] ?? "");
+  };
+  const [cmd] = args;
+
+  /* run needs no studio: it is the pipeline on this machine */
+  if (cmd === "run") {
+    const [, tool, ...rest] = args;
+    if (!tool || !/^[a-z0-9_-]+$/i.test(tool)) fail("uso: omni run <ferramenta> [args…]");
+    const mjs = join(CODE_ROOT, "tools", `${tool}.mjs`);
+    const py = join(CODE_ROOT, "tools", `${tool.replace(/-/g, "_")}.py`);
+    const venv = join(CODE_ROOT, ".venv", "bin", "python");
+    const [bin, script] = existsSync(mjs)
+      ? [process.execPath, mjs]
+      : existsSync(py)
+        ? [existsSync(venv) ? venv : "python3", py]
+        : [];
+    if (!bin) fail(`não existe a ferramenta ${tool}`);
+    const r = spawnSync(/** @type {string} */ (bin), [/** @type {string} */ (script), ...rest], {
+      stdio: "inherit",
+      env: { ...process.env, OMNI_HOME: DATA_ROOT },
+    });
+    process.exit(r.status ?? 1);
+  }
+
+  if (cmd === "doctor") {
+    const r = spawnSync(process.execPath, [join(CODE_ROOT, "tools", "setup.mjs"), "check"], {
+      stdio: "inherit",
+      env: { ...process.env, OMNI_HOME: DATA_ROOT },
+    });
+    process.exit(r.status ?? 1);
+  }
+
+  const url = studioUrl();
+
+  if (cmd === "skill") {
+    const name = args[1] ?? "";
+    const [part] = String(flag("part") ?? "1").split("/");
+    /* always text and exit 0: Claude Code puts this output where the skill's instructions go */
+    console.log(
+      await skillText({
+        studioUrl: url,
+        name,
+        version: flag("v"),
+        part: Number(part) || 1,
+        codeRoot: CODE_ROOT,
+        token: () => accessToken(url),
+      }),
+    );
+    return;
+  }
+
+  if (cmd === "mcp") return serveMcp({ name: "omnivideo", version: version(), tools: mcpTools(url) });
+
+  if (cmd === "up") {
+    const hook = args.includes("--hook");
+    try {
+      const r = await up({ hook, log: line => !hook && console.log(line) });
+      console.log(r.line);
+    } catch (e) {
+      /* a hook never fails the session: it says what went wrong and exits clean */
+      console.log(`OmniVideo: não consegui preparar este computador (${/** @type {Error} */ (e).message}).`);
+      if (!hook) process.exit(1);
+    }
+    return;
+  }
+
+  if (cmd === "allow") {
+    const rules = missingRules();
+    if (!rules.length) return console.log("As regras das skills do OmniVideo já estão nas settings do Claude Code.");
+    console.log(
+      `As skills do OmniVideo precisam destas regras em ${settingsFile()}:\n${rules.map(r => `  ${r}`).join("\n")}`,
+    );
+    if (!args.includes("--yes") && !(await confirm("Gravar?"))) return console.log("Nada gravado.");
+    allowSkillRules();
+    return console.log("Regras gravadas.");
+  }
+
+  if (cmd === "login" || cmd === "setup") {
+    if (cmd === "login" || !readTokens(url)) {
+      const t = await login(url, { deviceName: flag("name") || deviceName(), log: line => console.log(line) }).catch(
+        e => fail(String(e.message)),
+      );
+      console.log(`Pronto: "${t.device_name}" entrou no OmniVideo. O login ficou no Keychain.`);
+    }
+    if (cmd === "login") return console.log("O studio deste computador passa a usar este login em até 30 segundos.");
+    if (
+      missingRules().length &&
+      (args.includes("--yes") || (await confirm("Liberar as skills do OmniVideo nas settings do Claude Code?")))
+    )
+      allowSkillRules();
+    console.log((await up({ log: line => console.log(line) })).line);
+    return console.log("Para usar no Claude Code: claude plugin install omnivideo --marketplace pedroflp/omni-plugin");
+  }
+
+  if (cmd === "logout") {
+    if (!readTokens(url)) return console.log("Este computador não está logado.");
+    const confirmed = await logout(url);
+    return console.log(
+      confirmed
+        ? "Este computador saiu do OmniVideo."
+        : "O login foi apagado aqui; o studio não respondeu, então confira em Dispositivos.",
+    );
+  }
+
+  if (cmd === "status") {
+    const a = await account(url).catch(e => fail(`o studio não respondeu: ${e.message}`));
+    if (args.includes("--json")) return console.log(JSON.stringify(a));
+    if (!a.logged_in) return console.log(`Este computador não está logado: ${CLI_COMMAND} login`);
+    console.log(`conta: ${a.email}`);
+    console.log(`computador: ${a.device?.name}`);
+    console.log(`plano: ${planText(a)}`);
+    console.log(`créditos: ${a.credits}`);
+    return;
+  }
+
+  fail(
+    "uso: omni up [--hook] | login | status [--json] | logout | allow [--yes] | setup | doctor | skill <nome> | run <ferramenta> … | mcp",
+  );
+}
+
+if (isMainModule(import.meta.url)) await main(process.argv.slice(2));

package/tools/omni_paths.py

@@ -0,0 +1,12 @@
+"""The two roots the Python tools work from, the same as tools/lib/paths.mjs.
+
+CODE_ROOT is this repo (or the folder the `omni` CLI extracts its tools into; OMNI_CODE_ROOT points it
+elsewhere). DATA_ROOT is the workspace with videos/, omnivideo.config.json, .env and the dot folders:
+OMNI_HOME, or the code root when it is not set.
+"""
+
+import os
+from pathlib import Path
+
+CODE_ROOT = Path(os.environ.get("OMNI_CODE_ROOT") or Path(__file__).resolve().parent.parent).resolve()
+DATA_ROOT = Path(os.environ.get("OMNI_HOME") or CODE_ROOT).resolve()