@crievo/omni 0.0.0-stage → 0.1.0

package/tools/metrics.mjs

@@ -0,0 +1,415 @@
+#!/usr/bin/env node
+/* ============================================================================
+   Metrics of the published videos, so the creator sees what worked and Claude
+   learns from it (the script and the analysis read these numbers). For now
+   Instagram only: the API returns views, reach, likes, comments, saves,
+   shares, average watch time and the skip rate in the first 3 seconds. The
+   second-by-second retention curve is not available through the API.
+
+     node tools/metrics.mjs collect [videos/<slug>]   takes the snapshots that are due (the agent calls it)
+     node tools/metrics.mjs collect --force           redoes the current reading of all now (the UI)
+     node tools/metrics.mjs show [videos/<slug>] [--json]
+     node tools/metrics.mjs agent [--json] | install | uninstall
+     node tools/metrics.mjs cloud push         the published Reels (duration and history) and the account up
+                                               to the cloud; with cloud.metrics the cloud collects from then on
+
+   With cloud.metrics in the config the cloud (cloud/omnichat) collects every hour, and
+   `collect` (the agent, every 4 h) pulls its records into the same files and registers the Reels published
+   since (with the MP4's duration, which only this machine measures). Without it, this machine collects.
+
+   Collection runs every 4 hours: each published Reel (`instagram.id` in
+   publication.json) gets one reading every 4 h in the first 30 days and one per
+   day after that (the API limit is about 200 calls per hour). Every reading
+   goes into `hourly`, the series the UI draws, and the newest is `current`.
+   The age milestones (1 h, 3 h, 24 h, 72 h, 7 and 30 days) are the readings
+   used to compare videos at the same age; a milestone is only taken near its
+   age (up to half a milestone later, at least 1 h): a missed window
+   goes without that snapshot instead of getting a skewed one (the 1 h and 3 h
+   ones only come when a pass falls in their window, or via Coletar agora). A lost
+   reading does not come back: that is why the agent runs on its own, every 4 hours.
+
+   Writes videos/<slug>/metrics.json:
+
+     { "instagram": { "id": "…", "published_at": "…", "duration_s": 73.1,
+         "snapshots": [ { "milestone": "1h", "at": "…", "age_h": 1.1, "views": 900,
+                      "reach": 700, "likes": 30, "comments": 4,
+                      "saves": 6, "shares": 2, "interactions": 42,
+                      "avg_watch_s": 14.2, "watched_pct": 19.4,
+                      "skip_3s_pct": 43, "total_watch_h": 3.5 } ],
+         "hourly": [ { …one reading per pass, no milestone… } ],
+         "current": { …the last of hourly… }, "error": null } }
+
+   `duration_s` is that of the MP4 that was uploaded (the sped-up version, if
+   that one), and `watched_pct` = average watch time ÷ that duration. The
+   account (followers, posts, profile visits in the day) goes to
+   .metrics/account.json: one snapshot per day, redone every pass (today's is
+   the newest), and every reading in `hourly`. Read only: no call from here
+   changes anything on Instagram.
+   ============================================================================ */
+
+import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync, readdirSync, unlinkSync } from "node:fs";
+import { join, resolve, dirname, basename } from "node:path";
+import { homedir } from "node:os";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { instagramToken, igClient, cloudSettings, cloudApi } from "./platforms.mjs";
+import {
+  AGENT_STEP_H,
+  collectVideo as coreCollectVideo,
+  collectAccount as coreCollectAccount,
+} from "./lib/metrics/metrics.mjs";
+import { isMainModule, homeEnvPlist, DATA_ROOT as ROOT } from "./lib/paths.mjs";
+
+const VIDEOS = join(ROOT, "videos");
+const DIR = join(ROOT, ".metrics");
+const ACCOUNT_FILE = join(DIR, "account.json");
+const LOCK_FILE = join(DIR, "running.lock");
+const LOG_FILE = join(DIR, "metrics.log");
+const AGENT = "com.omnivideo.metrics";
+const PLIST = join(homedir(), "Library", "LaunchAgents", `${AGENT}.plist`);
+const SELF = fileURLToPath(import.meta.url);
+const args = process.argv.slice(2);
+const fail = msg => {
+  console.error(`erro: ${msg}`);
+  process.exit(1);
+};
+const now = () => new Date().toISOString();
+
+function readJson(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeJson(file, data) {
+  mkdirSync(dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n");
+  renameSync(tmp, file);
+}
+
+/* videos with a published Reel: id and time come from publication.json */
+function published(only) {
+  const dirs = only ? [resolve(only)] : existsSync(VIDEOS) ? readdirSync(VIDEOS).map(n => join(VIDEOS, n)) : [];
+  return dirs
+    .map(dir => ({ dir, ig: readJson(join(dir, "publication.json"))?.instagram }))
+    .filter(v => v.ig?.id && v.ig?.published_at);
+}
+
+/* duration of the uploaded MP4; without it (deleted, other machine), the one in assembly.json */
+function publishedDuration(dir, ig) {
+  if (ig.mp4 && existsSync(join(dir, ig.mp4))) {
+    const r = spawnSync(
+      "ffprobe",
+      ["-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", join(dir, ig.mp4)],
+      { encoding: "utf8" },
+    );
+    const d = parseFloat(r.stdout);
+    if (Number.isFinite(d)) return Math.round(d * 10) / 10;
+  }
+  const a = readJson(join(dir, "export", "assembly.json"));
+  return a?.duration ?? null;
+}
+
+/* one video: the core decides what is due and reads it; this side reads and writes metrics.json */
+async function collectVideo(client, { dir, ig }, force, retryRemoved = force) {
+  const file = join(dir, "metrics.json");
+  const data = readJson(file) ?? {};
+  const r = await coreCollectVideo({
+    client,
+    ig,
+    stored: data.instagram,
+    duration: () => publishedDuration(dir, ig),
+    force,
+    retryRemoved,
+  });
+  if (!r) return null;
+  data.instagram = r.rec;
+  writeJson(file, data);
+  return { slug: basename(dir), milestones: r.milestones, error: r.error };
+}
+
+/* the account: one snapshot per day, redone every pass (today's is the newest) */
+async function collectAccount(client, force) {
+  const account = await coreCollectAccount({ client, stored: readJson(ACCOUNT_FILE), force });
+  if (!account) return false;
+  writeJson(ACCOUNT_FILE, account);
+  return true;
+}
+
+/* one pass at a time: the 4-hourly agent and someone in the terminal don't write together */
+function lock() {
+  mkdirSync(DIR, { recursive: true });
+  const owner = Number(readJson(LOCK_FILE)?.pid);
+  if (owner && owner !== process.pid) {
+    try {
+      process.kill(owner, 0);
+      return null;
+    } catch {
+      /* lock of a pass that died */
+    }
+  }
+  writeJson(LOCK_FILE, { pid: process.pid, since: now() });
+  return () => {
+    try {
+      unlinkSync(LOCK_FILE);
+    } catch {
+      /* already gone */
+    }
+  };
+}
+
+/* --- the cloud: it collects, this machine mirrors ---------------------------------------- */
+const cloudCollects = () => cloudSettings().owns.metrics;
+
+/* a Reel the cloud reads: with the duration measured here, and the history when asked (the push) */
+async function registerVideo({ dir, ig }, withRecord) {
+  const m = readJson(join(dir, "metrics.json"))?.instagram;
+  await cloudApi("PUT", `/api/metrics/videos/${ig.id}`, {
+    name: basename(dir),
+    published_at: ig.published_at,
+    duration_s: m?.duration_s ?? publishedDuration(dir, ig),
+    ...(withRecord && m?.id === ig.id ? { record: m } : {}),
+  });
+}
+
+/* the cloud's records into metrics.json and account.json; the Reels it does not know yet go up */
+async function pull(only) {
+  const c = await cloudApi("GET", "/api/metrics");
+  const there = new Map((c.videos ?? []).map(v => [v.media_id, v]));
+  let n = 0;
+  for (const v of published(only)) {
+    const cv = there.get(v.ig.id);
+    if (!cv) {
+      await registerVideo(v, true);
+      continue;
+    }
+    if (!cv.record) continue;
+    const file = join(v.dir, "metrics.json");
+    const data = readJson(file) ?? {};
+    if (JSON.stringify(data.instagram) === JSON.stringify(cv.record)) continue;
+    data.instagram = cv.record;
+    writeJson(file, data);
+    n++;
+  }
+  /* only a change is written: the write is a studio notice */
+  if (c.account && !only && JSON.stringify(readJson(ACCOUNT_FILE)) !== JSON.stringify(c.account)) {
+    mkdirSync(DIR, { recursive: true });
+    writeJson(ACCOUNT_FILE, c.account);
+  }
+  if (n) console.log(`${now()} ${n} vídeo(s) atualizado(s) da cloud`);
+}
+
+async function cloudPush() {
+  if (!cloudSettings().ready) fail("cloud não configurada: cloud.url no config e OMNICHAT_CLOUD_SECRET no .env");
+  const { token, id } = await instagramToken();
+  await cloudApi("PUT", "/api/account", { id, token });
+  const videos = published(null);
+  for (const v of videos) await registerVideo(v, true);
+  const account = readJson(ACCOUNT_FILE);
+  if (account) await cloudApi("PUT", "/api/metrics/account", { record: account });
+  await cloudApi("PUT", "/api/metrics/active", { active: cloudCollects() });
+  console.log(`${videos.length} Reel(s) e a conta na cloud`);
+  console.log(
+    cloudCollects()
+      ? "a cloud coleta de hora em hora; o agente daqui só puxa (cloud.metrics)"
+      : "a cloud recebeu, mas quem coleta ainda é esta máquina (cloud.metrics: true para virar)",
+  );
+}
+
+async function collect(only) {
+  if (cloudCollects()) {
+    /* "Coletar agora" (--force or a video named): the cloud reads now; then this machine pulls */
+    if (only || args.includes("--force")) {
+      const r = await cloudApi("POST", "/api/metrics/run", { force: true });
+      if (r.done?.length) console.log(`${now()} cloud: ${r.done.join(" · ")}`);
+    }
+    await pull(only);
+    return;
+  }
+  const release = lock();
+  if (!release) {
+    console.log("outra passada das métricas está rodando: esta sai sem fazer nada");
+    return;
+  }
+  try {
+    const client = igClient((await instagramToken()).token);
+    const force = !!only || args.includes("--force");
+    const done = [];
+    for (const v of published(only)) {
+      const r = await collectVideo(client, v, force, !!only);
+      if (r) done.push(r);
+    }
+    const account = await collectAccount(client, force);
+    const rows = done.map(
+      r =>
+        `${r.slug}: ${r.error ? `erro: ${r.error}` : r.milestones.length ? `leitura + marcos ${r.milestones.join(", ")}` : "leitura"}`,
+    );
+    if (rows.length || account)
+      console.log(`${now()} ${[...rows, account ? "conta" : ""].filter(Boolean).join(" · ")}`);
+  } finally {
+    release();
+  }
+}
+
+/* --- show ------------------------------------------------------------------------ */
+function table(only) {
+  const rows = published(only)
+    .map(({ dir, ig }) => {
+      const m = readJson(join(dir, "metrics.json"))?.instagram;
+      const pub = readJson(join(dir, "publication.json"));
+      return {
+        slug: basename(dir),
+        title: pub?.title ?? null,
+        published_at: ig.published_at,
+        url: ig.url ?? null,
+        duration_s: m?.duration_s ?? null,
+        current: m?.current ?? null,
+        snapshots: m?.snapshots ?? [],
+        hourly: m?.hourly ?? [],
+        error: m?.error ?? null,
+        removed: !!m?.removed,
+      };
+    })
+    .sort((a, b) => b.published_at.localeCompare(a.published_at));
+  const account = readJson(ACCOUNT_FILE);
+  return { videos: rows, account: account?.snapshots ?? [], account_hourly: account?.hourly ?? [] };
+}
+
+function show(only) {
+  const t = table(only);
+  if (args.includes("--json")) {
+    console.log(JSON.stringify(t, null, 2));
+    return;
+  }
+  const n = v => (v == null ? "–" : String(v));
+  const age = h => (h == null ? "–" : h < 48 ? `${Math.round(h)} h` : `${Math.round(h / 24)} d`);
+  console.log(
+    "vídeo                                   idade  views  pulo3s  assistido    salvos  compart.  coment.  dur.",
+  );
+  for (const v of t.videos) {
+    const a = v.current;
+    const label = (v.title ?? v.slug).slice(0, 38).padEnd(38);
+    if (!a) {
+      console.log(`${label}  sem leitura ainda${v.error ? ` (${v.error.message})` : ""}`);
+      continue;
+    }
+    console.log(
+      `${label}  ${age(a.age_h).padStart(5)}  ${n(a.views).padStart(5)}  ${(a.skip_3s_pct == null ? "–" : `${a.skip_3s_pct}%`).padStart(6)}  ${(a.avg_watch_s == null ? "–" : `${a.avg_watch_s} s (${n(a.watched_pct)}%)`).padEnd(11)}  ${n(a.saves).padStart(6)}  ${n(a.shares).padStart(8)}  ${n(a.comments).padStart(7)}  ${n(v.duration_s)} s`,
+    );
+  }
+  const c = t.account.at(-1);
+  if (c)
+    console.log(
+      `\nconta @${c.username}: ${n(c.followers)} seguidores, ${n(c.posts)} posts, ${n(c.profile_visits_day)} visitas ao perfil hoje (foto de ${new Date(c.at).toLocaleString("pt-BR")})`,
+    );
+  if (cloudCollects()) console.log("\ncoleta: a cloud, de hora em hora (o agente daqui só puxa)");
+  else if (!agentStatus().loaded)
+    console.log("\naviso: o agente está desligado e marco perdido não volta: node tools/metrics.mjs agent install");
+}
+
+/* --- the launchd agent -------------------------------------------------------------------
+   Runs `collect` every 4 hours with the node that installed it. It does not wake the Mac:
+   while asleep, those hours' readings are lost, and collection resumes when it wakes. */
+const domain = () => `gui/${process.getuid()}`;
+const launchctl = (...a) => spawnSync("launchctl", a, { encoding: "utf8" });
+
+function agentStatus() {
+  const installed = existsSync(PLIST);
+  return { installed, loaded: installed && launchctl("print", `${domain()}/${AGENT}`).status === 0, log: LOG_FILE };
+}
+
+function installAgent() {
+  const x = s => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  /* ffprobe measures the published MP4: launchd starts without the shell's PATH */
+  const path = [
+    ...new Set([
+      dirname(process.execPath),
+      "/opt/homebrew/bin",
+      "/usr/local/bin",
+      ...(process.env.PATH ?? "").split(":"),
+      "/usr/bin",
+      "/bin",
+    ]),
+  ]
+    .filter(Boolean)
+    .join(":");
+  mkdirSync(DIR, { recursive: true });
+  mkdirSync(dirname(PLIST), { recursive: true });
+  writeFileSync(
+    PLIST,
+    `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${AGENT}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${x(process.execPath)}</string>
+    <string>${x(SELF)}</string>
+    <string>collect</string>
+  </array>
+  <key>WorkingDirectory</key><string>${x(ROOT)}</string>
+  <key>EnvironmentVariables</key>
+  <dict><key>PATH</key><string>${x(path)}</string>${homeEnvPlist(x)}</dict>
+  <key>StartInterval</key><integer>${AGENT_STEP_H * 3600}</integer>
+  <key>RunAtLoad</key><true/>
+  <key>StandardOutPath</key><string>${x(LOG_FILE)}</string>
+  <key>StandardErrorPath</key><string>${x(LOG_FILE)}</string>
+</dict>
+</plist>
+`,
+  );
+  launchctl("bootout", `${domain()}/${AGENT}`);
+  let r;
+  for (let i = 0; i < 6; i++) {
+    r = launchctl("bootstrap", domain(), PLIST);
+    if (r.status === 0) break;
+    spawnSync("sleep", ["0.5"]);
+  }
+  if (r.status !== 0) fail(`launchctl bootstrap: ${(r.stderr || r.stdout).trim()}`);
+  console.log(
+    `agente das métricas ligado: coleta de ${AGENT_STEP_H} em ${AGENT_STEP_H} horas, com o studio aberto ou não (log em .metrics/metrics.log)`,
+  );
+}
+
+function uninstallAgent() {
+  launchctl("bootout", `${domain()}/${AGENT}`);
+  try {
+    unlinkSync(PLIST);
+  } catch {
+    /* wasn't there */
+  }
+  console.log("agente das métricas desligado: as leituras até você ligar de novo se perdem");
+}
+
+/* ============================================================================
+   CLI only: the studio imports table */
+export { table, agentStatus };
+const isMain = isMainModule(import.meta.url);
+if (isMain) {
+  const [cmd, sub] = args;
+  const video = cmd !== "agent" && cmd !== "cloud" && sub && !sub.startsWith("--") ? sub : null;
+  if (video && !existsSync(join(resolve(video), "publication.json"))) fail(`${video} não tem publication.json`);
+  try {
+    if (cmd === "collect") await collect(video);
+    else if (cmd === "cloud" && sub === "push") await cloudPush();
+    else if (cmd === "show") show(video);
+    else if (cmd === "agent" && sub === "install") installAgent();
+    else if (cmd === "agent" && sub === "uninstall") uninstallAgent();
+    else if (cmd === "agent") {
+      const s = agentStatus();
+      if (args.includes("--json")) console.log(JSON.stringify(s));
+      else
+        console.log(
+          `agente: ${s.loaded ? `ligado, coleta de ${AGENT_STEP_H} em ${AGENT_STEP_H} horas` : "desligado (node tools/metrics.mjs agent install)"}`,
+        );
+    } else
+      fail(
+        "uso: metrics.mjs collect [videos/<slug>] [--force] · show [videos/<slug>] [--json] · agent [install|uninstall] · cloud push",
+      );
+  } catch (e) {
+    fail(e.message);
+  }
+}

package/tools/models.mjs

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+/* ============================================================================
+   Claude model and effort per stage.
+
+     node tools/models.mjs            the table: config × what is in the skills
+     node tools/models.mjs apply      writes into the skills what the config says
+
+   The source of truth is `models` in omnivideo.config.json:
+
+     "models": {
+       "orchestrator": { "model": "sonnet", "effort": "medium" },   studio session that runs the video
+       "reference":    { "model": "opus",   "effort": "high" },     studio session that measures a reference
+       "stages": { "av-script": { "model": "opus", "effort": "high" }, … }
+     }
+
+   Each stage skill runs in a fork (`context: fork`): a subagent with its own
+   model and effort, a clean context (it reads scenes.json, not the chat) and a
+   report back to the caller. The fork is what really switches the model: in a
+   `claude -p`, `model:` in a skill without fork is ignored (measured on
+   12/10/2026, Claude Code 2.1.284). `apply` writes `model`, `effort` and
+   `context: fork` in the frontmatter of .claude/skills/<stage>/SKILL.md; the
+   orchestrator (`omnivideo`) is not a fork, its model is the session's.
+
+   Models: fable, opus, sonnet, haiku (the alias points to the newest) or the
+   full id. Effort: low, medium, high, xhigh, max; Haiku 4.x has no effort (the
+   5.5, which the `haiku` alias calls since 7/10/2026, does).
+   ============================================================================ */
+
+import { readFileSync, writeFileSync, existsSync, renameSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { CODE_ROOT, isMainModule, DATA_ROOT as ROOT } from "./lib/paths.mjs";
+
+const SKILLS = join(CODE_ROOT, ".claude", "skills");
+
+export const MODELS = ["fable", "opus", "sonnet", "haiku"];
+export const EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+const noEffort = m => /haiku-4/.test(m);
+
+export function readModels() {
+  const cfg = JSON.parse(readFileSync(join(ROOT, "omnivideo.config.json"), "utf8"));
+  return cfg.models ?? { stages: {} };
+}
+
+export function validate(m) {
+  if (!m || typeof m !== "object") return "faltou modelo e effort";
+  if (!(MODELS.includes(m.model) || /^claude-[a-z0-9-]+$/.test(m.model ?? "")))
+    return `modelo desconhecido: ${m.model}`;
+  if (m.effort != null && !EFFORTS.includes(m.effort)) return `effort desconhecido: ${m.effort}`;
+  return null;
+}
+
+/* a skill's frontmatter as pairs, in file order */
+function frontmatter(text) {
+  const m = /^---\n([\s\S]*?)\n---\n?/.exec(text);
+  if (!m) return null;
+  const pairs = m[1].split("\n").map(l => {
+    const i = l.indexOf(":");
+    return [l.slice(0, i).trim(), l.slice(i + 1).trim()];
+  });
+  return { pairs, rest: text.slice(m[0].length) };
+}
+
+export function inSkill(stage) {
+  const file = join(SKILLS, stage, "SKILL.md");
+  if (!existsSync(file)) return null;
+  const fm = frontmatter(readFileSync(file, "utf8"));
+  const v = Object.fromEntries(fm?.pairs ?? []);
+  return { model: v.model ?? null, effort: v.effort ?? null, fork: v.context === "fork" };
+}
+
+/* writes model/effort/context in the frontmatter, after the description; returns what changed */
+export function applyModels() {
+  const { stages = {} } = readModels();
+  const changes = [];
+  for (const [stage, m] of Object.entries(stages)) {
+    const error = validate(m);
+    if (error) throw new Error(`${stage}: ${error}`);
+    const file = join(SKILLS, stage, "SKILL.md");
+    if (!existsSync(file)) throw new Error(`${stage}: .claude/skills/${stage}/SKILL.md não existe`);
+    const text = readFileSync(file, "utf8");
+    const fm = frontmatter(text);
+    if (!fm) throw new Error(`${stage}: SKILL.md sem frontmatter`);
+    const added = [
+      ["model", m.model],
+      ...(noEffort(m.model) || !m.effort ? [] : [["effort", m.effort]]),
+      ["context", "fork"],
+    ];
+    const pairs = fm.pairs.filter(([k]) => !["model", "effort", "context"].includes(k));
+    const i = pairs.findIndex(([k]) => k === "description");
+    pairs.splice(i < 0 ? pairs.length : i + 1, 0, ...added);
+    const updated = `---\n${pairs.map(([k, v]) => `${k}: ${v}`).join("\n")}\n---\n${fm.rest}`;
+    if (updated === text) continue;
+    const tmp = `${file}.${process.pid}.tmp`;
+    writeFileSync(tmp, updated);
+    renameSync(tmp, file);
+    changes.push(`${stage}: ${m.model}${added.some(([k]) => k === "effort") ? ` · ${m.effort}` : ""}`);
+  }
+  return changes;
+}
+
+/* --- cli ------------------------------------------------------------------------ */
+if (isMainModule(import.meta.url)) {
+  const cmd = process.argv[2];
+  try {
+    if (cmd === "apply") {
+      const m = applyModels();
+      console.log(m.length ? `skills atualizadas:\n  ${m.join("\n  ")}` : "as skills já estão como a config diz");
+    } else if (!cmd) {
+      const { orchestrator, reference, stages = {} } = readModels();
+      const f = m => (m ? `${m.model}${m.effort && !noEffort(m.model) ? ` · ${m.effort}` : ""}` : "(padrão da sessão)");
+      console.log(`orquestrador  ${f(orchestrator)}`);
+      console.log(`estilo visual ${f(reference)}`);
+      for (const [stage, m] of Object.entries(stages)) {
+        const s = inSkill(stage);
+        const same = s && s.model === m.model && (noEffort(m.model) || s.effort === (m.effort ?? null)) && s.fork;
+        console.log(
+          `${stage.padEnd(13)} ${f(m).padEnd(18)} ${same ? "" : `⚠ na skill: ${s ? `${s.model ?? "—"} · ${s.effort ?? "—"}${s.fork ? "" : " · sem fork"}` : "não existe"} (rode apply)`}`,
+        );
+      }
+    } else {
+      console.log(
+        readFileSync(fileURLToPath(import.meta.url), "utf8")
+          .split("\n")
+          .slice(1, 27)
+          .join("\n"),
+      );
+      process.exit(2);
+    }
+  } catch (e) {
+    console.error(`erro: ${e.message}`);
+    process.exit(1);
+  }
+}