@crievo/omni 0.0.0-stage → 0.1.0

package/tools/lib/skill-client.mjs

@@ -0,0 +1,126 @@
+/* `omni skill <name>`: what a plugin header's `!` line runs (docs/specs/phase-2-plugin-cli.md, step 3).
+   It asks the registry for one part of the skill's body with this machine's login, writes the skill's
+   sibling files to a temporary folder, fills the release's placeholders ({{OMNI_CODE}} with the code
+   root, {{OMNI_SKILLS}}/<name>/ with that folder) and returns the text the model reads.
+
+   Whatever happens, it returns text and never fails: Claude Code puts the output where the skill's
+   instructions go, so a refusal has to be readable instructions too ("pare e avise o usuário"). No
+   network, no skill: there is no offline copy.
+
+   The folder is $TMPDIR/omni-skills/<name>@<hash>/ (0700, files 0600). It goes away on a refusal for
+   that skill and after an hour unused, swept on every call. */
+
+import { chmodSync, mkdirSync, readdirSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, normalize, relative } from "node:path";
+
+export const UNUSED_MS = 60 * 60_000;
+
+const stop = (/** @type {string} */ why) =>
+  `Pare aqui: não siga esta skill nem a refaça de memória. Avise o usuário, em português: ${why}`;
+
+/** @param {string} base @param {() => number} now */
+function sweep(base, now) {
+  let names = [];
+  try {
+    names = readdirSync(base);
+  } catch {
+    return;
+  }
+  for (const n of names) {
+    const dir = join(base, n);
+    try {
+      if (now() - statSync(dir).mtimeMs > UNUSED_MS) rmSync(dir, { recursive: true, force: true });
+    } catch {
+      /* gone already */
+    }
+  }
+}
+
+/** removes every folder of one skill (a refusal) @param {string} base @param {string} name */
+function wipe(base, name) {
+  try {
+    for (const n of readdirSync(base))
+      if (n.startsWith(`${name}@`)) rmSync(join(base, n), { recursive: true, force: true });
+  } catch {
+    /* nothing there */
+  }
+}
+
+/** writes the files into the skill's folder, refusing any path that leaves it
+ *  @param {string} dir @param {Record<string, string>} files */
+function materialize(dir, files) {
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  chmodSync(dir, 0o700);
+  for (const [path, text] of Object.entries(files)) {
+    const target = normalize(join(dir, path));
+    if (relative(dir, target).startsWith("..")) continue;
+    mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
+    writeFileSync(target, text, { mode: 0o600 });
+  }
+}
+
+/**
+ * @param {{
+ *   studioUrl: string,
+ *   name: string,
+ *   version?: string,
+ *   part?: number,
+ *   codeRoot: string,
+ *   token: () => Promise<string | null>,
+ *   fetch?: typeof fetch,
+ *   base?: string,
+ *   now?: () => number,
+ * }} o
+ * @returns {Promise<string>} the text for the model
+ */
+export async function skillText(o) {
+  const base = o.base ?? join(tmpdir(), "omni-skills");
+  const now = o.now ?? Date.now;
+  const part = o.part ?? 1;
+  sweep(base, now);
+  if (!/^[a-z0-9-]{1,64}$/.test(o.name)) return stop(`o nome de skill "${o.name}" não é válido.`);
+
+  let token;
+  try {
+    token = await o.token();
+  } catch {
+    return stop(
+      "o OmniVideo está sem conexão, e as skills não abrem sem rede. Tente de novo quando a internet voltar.",
+    );
+  }
+  if (!token) return stop("este computador não está logado no OmniVideo. Rode `omni login` e peça de novo.");
+
+  const url = new URL(`/skills/${o.name}`, o.studioUrl);
+  if (o.version) url.searchParams.set("v", o.version);
+  url.searchParams.set("part", String(part));
+  /** @type {Response} */
+  let r;
+  try {
+    r = await (o.fetch ?? fetch)(url, { headers: { authorization: `Bearer ${token}` } });
+  } catch {
+    return stop(
+      "o OmniVideo está sem conexão, e as skills não abrem sem rede. Tente de novo quando a internet voltar.",
+    );
+  }
+  const j = /** @type {any} */ (await r.json().catch(() => ({})));
+  if (r.status === 401)
+    return stop("o login deste computador no OmniVideo não vale mais. Rode `omni login` e peça de novo.");
+  if (r.status === 403) {
+    wipe(base, o.name);
+    return stop(
+      `${j.error ?? "a assinatura do OmniVideo não está ativa."} Os vídeos continuam no computador; as skills voltam com o plano.`,
+    );
+  }
+  if (!r.ok || typeof j.body !== "string")
+    return stop(`o OmniVideo não entregou a skill ${o.name} (${j.error ?? `HTTP ${r.status}`}).`);
+
+  const dir = join(base, `${o.name}@${String(j.hash).slice(0, 16)}`);
+  if (part === 1 && j.files && Object.keys(j.files).length) materialize(dir, j.files);
+  try {
+    utimesSync(dir, new Date(now()), new Date(now()));
+  } catch {
+    /* no files for this skill */
+  }
+  return j.body.replaceAll("{{OMNI_CODE}}", o.codeRoot).replaceAll(`{{OMNI_SKILLS}}/${o.name}/`, `${dir}/`);
+}

package/tools/lib/skills-release.mjs

@@ -0,0 +1,196 @@
+/* A release of the skills for the registry and the public plugin (docs/specs/phase-2-plugin-cli.md, step 3).
+   One source, .claude/skills, serves both this repo (as it is) and the product (as built here):
+
+   - The body is rewritten for a machine that has the CLI and not this repo: `node tools/x.mjs …` and
+     `$PY tools/x.py …` become `<run> x …` (by default `npx -y @crievo/omni run x …`), `templates/…` and
+     `reference/…` become `{{OMNI_CODE}}/templates/…` and `{{OMNI_CODE}}/reference/…` and `.claude/skills/<name>/<file>` becomes
+     `{{OMNI_SKILLS}}/<name>/<file>`. `omni skill` fills the two placeholders when it prints the body.
+   - A body longer than one `!` line carries (MAX_PART characters, measured in the encrypted-skills study)
+     is cut at its `## ` headings into parts; the plugin's header gets one `!` line per part.
+   - The header keeps the frontmatter Claude Code reads (name, description, model, effort, context) and
+     only the lines that fetch the body, plus the plan-B line for when shell execution in skills is off.
+   - Every skill gets a hash of what it serves; the release's version is the hash of all of them.
+
+   Pure: the files come in as strings, so the tests need no disk. */
+
+import { createHash } from "node:crypto";
+import { CLI_COMMAND } from "./cli.mjs";
+
+export const MAX_PART = 24_000;
+export const DEFAULT_RUN = `${CLI_COMMAND} run`;
+export const DEFAULT_SKILL = `${CLI_COMMAND} skill`;
+/* the frontmatter keys the header keeps; anything else stays in the private body */
+const HEADER_KEYS = ["name", "description", "model", "effort", "context"];
+
+/** @param {string} text @returns {{ meta: Record<string, string>, metaLines: string[], body: string }} */
+export function splitFrontmatter(text) {
+  const m = text.match(/^---\n([\s\S]*?)\n---\n?/);
+  if (!m) return { meta: {}, metaLines: [], body: text };
+  const metaLines = m[1].split("\n");
+  /** @type {Record<string, string>} */
+  const meta = {};
+  for (const line of metaLines) {
+    const kv = line.match(/^([A-Za-z_-]+):\s*(.*)$/);
+    if (kv) meta[kv[1]] = kv[2];
+  }
+  return { meta, metaLines, body: text.slice(m[0].length) };
+}
+
+/** The body as a CLI machine runs it, and what the rewrite couldn't place.
+ *  @param {string} body @param {{ run?: string }} [o] @returns {{ body: string, warnings: string[] }} */
+export function rewriteBody(body, { run = DEFAULT_RUN } = {}) {
+  let out = body
+    .replace(/\bnode (?:\.\/)?tools\/([A-Za-z0-9_-]+)\.mjs\b/g, (_, t) => `${run} ${t}`)
+    .replace(/(?:"\$PY"|\$PY|\.venv\/bin\/python3?) (?:\.\/)?tools\/([A-Za-z0-9_-]+)\.py\b/g, (_, t) => `${run} ${t}`)
+    .replace(/(^|[^\w./{}-])(templates|reference)\//g, (_, pre, dir) => `${pre}{{OMNI_CODE}}/${dir}/`)
+    .replace(/(^|[^\w./{}-])\.claude\/skills\//g, (_, pre) => `${pre}{{OMNI_SKILLS}}/`);
+  /** @type {string[]} */
+  const warnings = [];
+  /* a command that still runs a repo tool by path would fail on a CLI machine */
+  for (const m of out.matchAll(/\b(?:node|python3?|bun) (?:\.\/)?tools\/[\w./-]+/g))
+    warnings.push(`chamada de ferramenta sem reescrita: ${m[0]}`);
+  out = out.replace(/\n{3,}/g, "\n\n");
+  return { body: out, warnings };
+}
+
+/** Cuts a body into parts of at most `max` characters, at `## ` headings, then `### `, then blank lines.
+ *  @param {string} body @param {number} [max] @returns {string[]} */
+export function splitParts(body, max = MAX_PART) {
+  if (body.length <= max) return [body];
+  /** @param {string} text @param {RegExp[]} seps @returns {string[]} */
+  const cut = (text, seps) => {
+    if (text.length <= max) return [text];
+    const [sep, ...rest] = seps;
+    if (!sep) {
+      /* no boundary left: a hard cut at a line end */
+      const at = text.lastIndexOf("\n", max) > 0 ? text.lastIndexOf("\n", max) : max;
+      return [text.slice(0, at), ...cut(text.slice(at), [])];
+    }
+    const pieces = text.split(sep).filter(p => p.length > 0);
+    /** @type {string[]} */
+    const parts = [];
+    let current = "";
+    for (const piece of pieces.flatMap(p => (p.length > max ? cut(p, rest) : [p]))) {
+      if (current && current.length + piece.length > max) {
+        parts.push(current);
+        current = "";
+      }
+      current += piece;
+    }
+    if (current) parts.push(current);
+    return parts;
+  };
+  return cut(body, [/(?=\n## )/, /(?=\n### )/, /(?=\n\n)/]);
+}
+
+const sha = (/** @type {string} */ s) => createHash("sha256").update(s).digest("hex");
+
+/** The plugin's SKILL.md for one skill: the public frontmatter and the lines that fetch the body.
+ *  @param {{ name: string, metaLines: string[], parts: number, version: string }} s @param {{ skill?: string }} [o] */
+export function header(s, { skill = DEFAULT_SKILL } = {}) {
+  const meta = s.metaLines.filter(l => HEADER_KEYS.includes(l.split(":")[0].trim()));
+  const fetchLines = Array.from({ length: s.parts }, (_, i) =>
+    s.parts === 1
+      ? `!\`${skill} ${s.name} --v ${s.version}\``
+      : `!\`${skill} ${s.name} --v ${s.version} --part ${i + 1}/${s.parts}\``,
+  );
+  const planB =
+    s.parts === 1
+      ? `Se acima aparecer o comando em vez das instruções, rode via Bash \`${skill} ${s.name} --v ${s.version}\` e siga a saída.`
+      : `Se acima aparecerem os comandos em vez das instruções, rode via Bash \`${skill} ${s.name} --v ${s.version} --part i/${s.parts}\` para cada parte, de 1 a ${s.parts}, e siga a saída.`;
+  return `---\n${meta.join("\n")}\n---\n\n${fetchLines.join("\n\n")}\n\n${planB}\n`;
+}
+
+/**
+ * The release: what the registry stores and what the plugin repo gets.
+ * @param {{ name: string, files: Record<string, string> }[]} skills each skill's files by path in its folder
+ *   (SKILL.md among them)
+ * @param {{ run?: string, skill?: string, max?: number }} [o]
+ */
+export function buildRelease(skills, o = {}) {
+  /** @type {string[]} */
+  const warnings = [];
+  const built = skills
+    .slice()
+    .sort((a, b) => a.name.localeCompare(b.name))
+    .map(({ name, files }) => {
+      const source = files["SKILL.md"];
+      if (source === undefined) throw new Error(`${name}: falta SKILL.md`);
+      const { meta, metaLines, body } = splitFrontmatter(source);
+      if (meta.name !== name) throw new Error(`${name}: o name do frontmatter é ${meta.name ?? "nenhum"}`);
+      const rewritten = rewriteBody(body, o);
+      warnings.push(...rewritten.warnings.map(w => `${name}: ${w}`));
+      const parts = splitParts(rewritten.body, o.max);
+      /** @type {Record<string, string>} */
+      const extra = {};
+      for (const [path, text] of Object.entries(files))
+        if (path !== "SKILL.md") extra[path] = rewriteBody(text, o).body;
+      const hash = sha(JSON.stringify({ parts, extra }));
+      return { name, meta, metaLines, parts, files: extra, hash };
+    });
+  const version = sha(built.map(s => `${s.name}:${s.hash}`).join("\n")).slice(0, 12);
+  return {
+    version,
+    warnings,
+    skills: built.map(s => ({
+      name: s.name,
+      hash: s.hash,
+      parts: s.parts,
+      files: s.files,
+      size: s.parts.join("").length,
+    })),
+    headers: Object.fromEntries(
+      built.map(s => [s.name, header({ name: s.name, metaLines: s.metaLines, parts: s.parts.length, version }, o)]),
+    ),
+  };
+}
+
+/**
+ * The public plugin, ready to be the marketplace repo (pedroflp/omni-plugin): the manifest, the
+ * marketplace that lists it, the SessionStart hook and the MCP server, both through the CLI, and the
+ * skills' headers. Its version is the hash of everything else, so Claude Code updates it only when some
+ * file changed.
+ * @param {{ headers: Record<string, string> }} release
+ * @param {{ cli: string, owner?: string }} o  cli: the command that runs the CLI (`npx -y @crievo/omni`)
+ * @returns {Record<string, string>} files by path
+ */
+export function pluginFiles(release, { cli, owner = "pedroflp" }) {
+  const description = "OmniVideo: roteiro, motion em código, voz clonada, legenda e publicação, do pedido ao MP4.";
+  const [command, ...args] = cli.split(" ");
+  /** @type {Record<string, string>} */
+  const files = {
+    "hooks/hooks.json": `${JSON.stringify(
+      {
+        hooks: {
+          SessionStart: [{ hooks: [{ type: "command", command: `${cli} up --hook`, async: true, timeout: 600 }] }],
+        },
+      },
+      null,
+      2,
+    )}\n`,
+    ".mcp.json": `${JSON.stringify({ mcpServers: { omnivideo: { command, args: [...args, "mcp"] } } }, null, 2)}\n`,
+    "README.md": `# OmniVideo para o Claude Code
+
+${description}
+
+    claude plugin install omnivideo --marketplace ${owner}/omni-plugin
+
+Na primeira sessão o plugin prepara o computador sozinho: abre o navegador para você entrar no OmniVideo e
+liga o studio local. Precisa do Chrome e do ffmpeg instalados. Este repositório é gerado automaticamente:
+as skills chegam do registro do OmniVideo a cada uso.
+`,
+    ...Object.fromEntries(Object.entries(release.headers).map(([name, text]) => [`skills/${name}/SKILL.md`, text])),
+  };
+  const version = `0.1.0-${sha(JSON.stringify(files)).slice(0, 10)}`;
+  files[".claude-plugin/plugin.json"] = `${JSON.stringify(
+    { name: "omnivideo", version, description, author: { name: "Crievo" }, homepage: "https://omni.crievo.com" },
+    null,
+    2,
+  )}\n`;
+  files[".claude-plugin/marketplace.json"] = `${JSON.stringify(
+    { name: "omnivideo", owner: { name: owner }, plugins: [{ name: "omnivideo", source: "./", description, version }] },
+    null,
+    2,
+  )}\n`;
+  return files;
+}

package/tools/lib/testing.mjs

@@ -0,0 +1,52 @@
+/* Test helpers for the core: a fake fetch with canned routes and a fixed clock. Not used at runtime. */
+
+/**
+ * A fake fetch for tests: each call takes the first route whose `match`
+ * (substring or RegExp, plus optional method) fits; records every call.
+ * @param {Array<{ match: string | RegExp, method?: string, status?: number, body?: any, headers?: Record<string, string> } | ((url: string, opts: any) => any)>} routes
+ */
+export function fakeFetch(routes) {
+  /** @type {Array<{ url: string, opts: any }>} */
+  const calls = [];
+  /** @type {typeof globalThis.fetch & { calls: typeof calls }} */
+  const f = /** @type {any} */ (
+    async (/** @type {string} */ url, /** @type {any} */ opts = {}) => {
+      calls.push({ url: String(url), opts });
+      for (const route of routes) {
+        const hit =
+          typeof route === "function"
+            ? route(String(url), opts)
+            : (typeof route.match === "string" ? String(url).includes(route.match) : route.match.test(String(url))) &&
+                (!route.method || route.method === (opts.method ?? "GET"))
+              ? route
+              : null;
+        if (!hit) continue;
+        const status = hit.status ?? 200;
+        const text = typeof hit.body === "string" ? hit.body : JSON.stringify(hit.body ?? {});
+        return new Response(text, { status, headers: hit.headers ?? {} });
+      }
+      throw new Error(`fakeFetch: no route for ${opts.method ?? "GET"} ${url}`);
+    }
+  );
+  f.calls = calls;
+  return f;
+}
+
+/**
+ * A clock that only moves when told to.
+ * @param {string | number} start ISO date or epoch ms
+ */
+export function fixedClock(start) {
+  let t = typeof start === "number" ? start : Date.parse(start);
+  return {
+    now: () => t,
+    /** @param {number} ms */
+    advance: ms => {
+      t += ms;
+    },
+    /** @param {number} ms */
+    sleep: async ms => {
+      t += ms;
+    },
+  };
+}

package/tools/lib/up.mjs

@@ -0,0 +1,187 @@
+/* `omni up`: everything the CLI needs on this machine, done without the user (docs/specs/phase-2-plugin-cli.md,
+   step 4). The plugin's SessionStart hook runs it on every session, so every piece checks first and does
+   nothing when it is already there:
+
+     workspace   ~/OmniVideo (OMNI_HOME): videos/, omnivideo.config.json pointing at the hosted studio, .env
+     app         a stable copy of the package in ~/.omni/app/<version>/ (npx's cache can be wiped), and
+                 ~/.omni/bin/omni
+     python      the venv of the voice and timing tools, in the app's .venv (in the background on a hook)
+     login       none yet: the browser opens on the approval page (at most once an hour)
+     service     the studio as a launchd agent, from the app, so the hosted studio reaches this Mac
+
+   In this repo (a git checkout) the app, the venv and the service are left to `tools/setup.mjs` and
+   `tools/runner.mjs service`: `up` never rewires a development machine. */
+
+import { spawn, spawnSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { missingRules } from "./claude-settings.mjs";
+import { CLI_COMMAND, PACKAGE, STUDIO_URL } from "./cli.mjs";
+import { readTokens } from "./oauth-client.mjs";
+import { CODE_ROOT, DATA_ROOT } from "./paths.mjs";
+import { PLIST, service, serviceInstall } from "./service.mjs";
+
+export const OMNI_DIR = join(homedir(), ".omni");
+const LOGIN_EVERY_MS = 60 * 60_000;
+
+const isDev = (/** @type {string} */ codeRoot) => existsSync(join(codeRoot, ".git"));
+
+/** the studio URL of a workspace's config, else the default */
+export function studioUrlOf(home = DATA_ROOT) {
+  try {
+    const c = JSON.parse(readFileSync(join(home, "omnivideo.config.json"), "utf8"));
+    return String(c.cloud?.studio_url || STUDIO_URL).replace(/\/+$/, "");
+  } catch {
+    return STUDIO_URL;
+  }
+}
+
+/** videos/, a config that talks to the hosted studio, and .env, from the package's examples
+ *  @returns {boolean} whether it created anything */
+export function ensureWorkspace(home = DATA_ROOT, codeRoot = CODE_ROOT) {
+  let created = false;
+  if (!existsSync(join(home, "videos"))) {
+    mkdirSync(join(home, "videos"), { recursive: true });
+    created = true;
+  }
+  const config = join(home, "omnivideo.config.json");
+  if (!existsSync(config)) {
+    const c = JSON.parse(readFileSync(join(codeRoot, "omnivideo.config.example.json"), "utf8"));
+    c.cloud = { ...(c.cloud ?? {}), studio: true, studio_url: STUDIO_URL };
+    writeFileSync(config, `${JSON.stringify(c, null, 2)}\n`);
+    created = true;
+  }
+  const env = join(home, ".env");
+  if (!existsSync(env) && existsSync(join(codeRoot, ".env.example"))) {
+    copyFileSync(join(codeRoot, ".env.example"), env);
+    created = true;
+  }
+  return created;
+}
+
+/** The code root the service should run: this checkout, an already stable install, or a fresh copy in
+ *  ~/.omni/app/<version>/ when this runs from npx's cache.  @param {(line: string) => void} log */
+export function ensureApp(log = () => {}, codeRoot = CODE_ROOT) {
+  if (isDev(codeRoot) || !codeRoot.includes("/_npx/")) return codeRoot;
+  const version = JSON.parse(readFileSync(join(codeRoot, "package.json"), "utf8")).version;
+  const prefix = join(OMNI_DIR, "app", version);
+  const installed = join(prefix, "node_modules", ...PACKAGE.split("/"));
+  if (!existsSync(join(installed, "package.json"))) {
+    log(`instalando o OmniVideo ${version} em ${prefix}…`);
+    const spec = process.env.OMNI_PACKAGE_SPEC || `${PACKAGE}@${version}`;
+    const r = spawnSync("npm", ["install", "--prefix", prefix, "--no-audit", "--no-fund", "--loglevel=error", spec], {
+      encoding: "utf8",
+    });
+    if (r.status !== 0) throw new Error(`npm install falhou: ${(r.stderr || r.stdout).trim().split("\n").at(-1)}`);
+  }
+  mkdirSync(join(OMNI_DIR, "bin"), { recursive: true });
+  writeFileSync(join(OMNI_DIR, "bin", "omni"), `#!/bin/sh\nexec node "${join(installed, "bin", "omni.mjs")}" "$@"\n`, {
+    mode: 0o755,
+  });
+  return installed;
+}
+
+/** the venv of the Python tools, inside the app; on a hook in the background, logging to ~/.omni/venv.log
+ *  @returns {"ok" | "started" | "creating" | "failed"} */
+export function ensureVenv(codeRoot = CODE_ROOT, { background = false } = {}) {
+  if (existsSync(join(codeRoot, ".venv", "bin", "python"))) return "ok";
+  const lock = join(OMNI_DIR, "venv.lock");
+  mkdirSync(OMNI_DIR, { recursive: true });
+  try {
+    if (Date.now() - statSync(lock).mtimeMs < 15 * 60_000) return "creating";
+  } catch {
+    /* no one is creating it */
+  }
+  writeFileSync(lock, String(process.pid));
+  const script = `python3 -m venv .venv && .venv/bin/python -m pip install -q -r requirements.txt; rm -f "${lock}"`;
+  if (background) {
+    const out = join(OMNI_DIR, "venv.log");
+    spawn("/bin/sh", ["-c", `${script} >> "${out}" 2>&1`], { cwd: codeRoot, detached: true, stdio: "ignore" }).unref();
+    return "started";
+  }
+  const r = spawnSync("/bin/sh", ["-c", script], { cwd: codeRoot, stdio: "inherit" });
+  return r.status === 0 ? "ok" : "failed";
+}
+
+/** opens the browser on the approval page in a process of its own, at most once an hour
+ *  @returns {boolean} whether it opened now */
+export function startLogin(codeRoot = CODE_ROOT) {
+  const marker = join(OMNI_DIR, "login-opened");
+  mkdirSync(OMNI_DIR, { recursive: true });
+  try {
+    if (Date.now() - statSync(marker).mtimeMs < LOGIN_EVERY_MS) return false;
+  } catch {
+    /* never opened */
+  }
+  writeFileSync(marker, new Date().toISOString());
+  spawn(process.execPath, [join(codeRoot, "tools", "omni.mjs"), "login"], {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env, OMNI_HOME: DATA_ROOT },
+  }).unref();
+  return true;
+}
+
+/** the checkout the installed studio service runs from, when it is a git checkout (a development machine) */
+function devServiceRoot() {
+  try {
+    const wd = /<key>WorkingDirectory<\/key><string>([^<]+)<\/string>/.exec(readFileSync(PLIST, "utf8"))?.[1];
+    const root = wd ? join(wd.replace(/&amp;/g, "&"), "..") : "";
+    return root && existsSync(join(root, ".git")) ? root : "";
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * @param {{ hook?: boolean, log?: (line: string) => void }} [o]
+ * @returns {Promise<{ line: string, codeRoot: string, loggedIn: boolean, missingRules: string[] }>}
+ */
+export async function up({ hook = false, log = () => {} } = {}) {
+  const notes = [];
+  if (ensureWorkspace()) notes.push(`workspace criado em ${DATA_ROOT}`);
+  const codeRoot = ensureApp(log);
+  const dev = isDev(codeRoot);
+  const url = studioUrlOf();
+
+  if (!dev) {
+    const venv = ensureVenv(codeRoot, { background: hook });
+    if (venv === "started" || venv === "creating") notes.push("preparando o Python das ferramentas de voz");
+    if (venv === "failed") notes.push("o Python das ferramentas não instalou (veja ~/.omni/venv.log)");
+  }
+
+  const loggedIn = !!readTokens(url);
+  if (!loggedIn)
+    notes.push(
+      startLogin(codeRoot) ? "abri o navegador para entrar no OmniVideo" : "falta entrar no OmniVideo (omni login)",
+    );
+
+  /* a development studio already kept on by launchd (this repo's runner.mjs) is never swapped for the app */
+  const devService = devServiceRoot();
+  if (!dev && devService)
+    notes.push(`o studio de desenvolvimento (${devService}) continua sendo o serviço deste computador`);
+  if (!dev && !devService && process.platform === "darwin") {
+    try {
+      if (serviceInstall({ codeRoot, onlyIfChanged: true, log }).changed) notes.push("studio ligado como serviço");
+    } catch (e) {
+      notes.push(`o serviço do studio não ligou: ${/** @type {Error} */ (e).message}`);
+    }
+  }
+
+  const rules = missingRules({ cli: CLI_COMMAND });
+  if (rules.length)
+    notes.push("as skills ainda precisam de permissão: peça ao Claude para liberar as skills do OmniVideo");
+
+  const s = service();
+  const state = [
+    loggedIn ? "logado" : "sem login",
+    dev ? "modo desenvolvimento" : s.loaded ? "studio ligado" : "studio desligado",
+  ];
+  return {
+    line: `OmniVideo: ${state.join(", ")}${notes.length ? `. ${notes.join("; ")}.` : "."}`,
+    codeRoot,
+    loggedIn,
+    missingRules: rules,
+  };
+}