@crievo/omni 0.0.0-stage → 0.1.1

package/tools/render.mjs

@@ -0,0 +1,426 @@
+#!/usr/bin/env node
+/* ============================================================================
+   Seek-safe scene renderer: HTML → PNG, contact sheet or video.
+
+     node tools/render.mjs scene.html out.mp4  --dur 5.4 --fps 30 --w 1080 --h 1920
+     node tools/render.mjs scene.html --still f.png --at 3.2
+     node tools/render.mjs scene.html --still f.png --at 3.2 --measure  # + box of each [data-continues]
+     node tools/render.mjs scene.html --sheet s.png --at 0,0.7,1.4,2.4
+     node tools/render.mjs scene.html out.webm --format webm          # with alpha
+     node tools/render.mjs scene.html frames/  --format png-sequence
+     node tools/render.mjs scene.html --frames dir/ --at 0.5,2.1 --alpha  # one PNG per t (q000.png…)
+     node tools/render.mjs scene.html --still f.png --eval "window.__warnings"  # + EVAL <json>
+     --alpha     transparent background in still and frames (the scene must not paint the body)
+     --jobs N    Chromes in parallel for video (default 3)
+     --gl        software WebGL2 for the scene (SwiftShader). Automatic when the source
+                 mentions webgl or VoiceAvatar; without it Chrome runs with --disable-gpu,
+                 which has no WebGL at all
+     --from S    the video starts at second S of the scene (default 0)
+
+   The scene contract: the frame at t depends only on t. The renderer writes
+   `--t` on the <html> style and waits two frames before capturing. The scene
+   signals it is mounted with `window.__ready = true` (after fonts, GSAP etc.).
+   CSS animation uses the [data-anim] rule; GSAP/Motion stay paused and are
+   positioned by a MutationObserver on that style. Base: templates/scene.html.
+
+   Requires Chrome/Chromium and ffmpeg.
+   ============================================================================ */
+
+import { spawn } from "node:child_process";
+import { mkdir, writeFile, rm, access, readdir } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+
+/* --- arguments ------------------------------------------------------------- */
+const argv = process.argv.slice(2);
+const flag = (n, d) => {
+  const i = argv.indexOf(`--${n}`);
+  return i < 0 ? d : argv[i + 1];
+};
+const has = n => argv.includes(`--${n}`);
+const positional = [];
+for (let i = 0; i < argv.length; i++) {
+  if (argv[i].startsWith("--")) {
+    if (flag(argv[i].slice(2), null) !== null) i++;
+    continue;
+  }
+  positional.push(argv[i]);
+}
+
+if (!positional[0]) {
+  console.error("uso: node render.mjs <scene.html> <out> [--dur N] [--fps N] [--w N] [--h N] [--jobs N]");
+  console.error("     node render.mjs <scene.html> --still f.png --at 3.2");
+  console.error("     node render.mjs <scene.html> --sheet s.png --at 0,1,2,3");
+  process.exit(1);
+}
+
+const SRC = resolve(positional[0]);
+const FMT = flag("format", "mp4");
+const FPS = +flag("fps", 30);
+const W = +flag("w", 1920),
+  H = +flag("h", 1080);
+const DUR = +flag("dur", 5);
+const FROM = +flag("from", 0);
+const JOBS = Math.max(1, +flag("jobs", 3));
+const AT = (flag("at", "") || "").split(",").filter(Boolean).map(Number);
+const MODE = has("still") ? "still" : has("sheet") ? "sheet" : has("frames") ? "frames" : "video";
+const OUT = resolve(
+  MODE === "still"
+    ? flag("still", "still.png")
+    : MODE === "sheet"
+      ? flag("sheet", "sheet.png")
+      : MODE === "frames"
+        ? flag("frames", "frames")
+        : (positional[1] ?? "out.mp4"),
+);
+const TMP = join(tmpdir(), `render-${process.pid}`);
+/* A WebGL scene needs a GL backend; the plain --disable-gpu Chrome has none. */
+const GL = has("gl") || /webgl|VoiceAvatar/i.test(readFileSync(SRC, "utf8"));
+
+/* --- Chrome ---------------------------------------------------------------- */
+async 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);
+  for (const p of fixed) {
+    try {
+      await access(p);
+      return p;
+    } catch {
+      /* next */
+    }
+  }
+  /* any Chromium in the Playwright cache, newest first */
+  const cache = `${process.env.HOME}/Library/Caches/ms-playwright`;
+  try {
+    const dirs = (await readdir(cache))
+      .filter(d => d.startsWith("chromium-"))
+      .sort()
+      .reverse();
+    for (const d of dirs) {
+      for (const sub of ["chrome-mac-arm64", "chrome-mac", "chrome-linux"]) {
+        for (const bin of [
+          "Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing",
+          "Chromium.app/Contents/MacOS/Chromium",
+          "chrome",
+        ]) {
+          const p = join(cache, d, sub, bin);
+          try {
+            await access(p);
+            return p;
+          } catch {
+            /* next */
+          }
+        }
+      }
+    }
+  } catch {
+    /* no cache */
+  }
+  throw new Error("Chrome não encontrado. Defina CHROME_PATH=/caminho/para/chrome");
+}
+
+/* One session = one Chrome process with one page. Parallel tabs in the same
+   Chrome don't work: a background tab has requestAnimationFrame throttled,
+   and the two-frame wait hangs. */
+async function openSession(chromePath, n) {
+  /* a truly free port: another session rendering at the same time may have a Chrome
+     on the PID-derived port, and connecting to it captures its page (learnings.md) */
+  let port = 9300 + ((process.pid * 7 + n * 31) % 600);
+  for (let t = 0; t < 50; t++) {
+    const taken = await fetch(`http://127.0.0.1:${port}/json/version`).then(
+      () => true,
+      () => false,
+    );
+    if (!taken) break;
+    port = 9300 + Math.floor(Math.random() * 6000);
+  }
+  const profile = join(TMP, `profile-${n}`);
+  const proc = spawn(
+    chromePath,
+    [
+      "--headless=new",
+      ...(GL
+        ? ["--use-angle=swiftshader", "--enable-unsafe-swiftshader", "--ignore-gpu-blocklist"]
+        : ["--disable-gpu"]),
+      "--hide-scrollbars",
+      "--force-device-scale-factor=1",
+      "--force-color-profile=srgb" /* no display profile leaking into the frame */,
+      "--disable-lcd-text" /* grayscale AA: subpixel flickers between frames */,
+      "--allow-file-access-from-files",
+      "--disable-background-timer-throttling",
+      "--disable-renderer-backgrounding",
+      `--window-size=${W},${H + 400}` /* the viewport opens ~140 px shorter: without slack, the bottom of the frame isn't painted (learnings.md) */,
+      `--remote-debugging-port=${port}`,
+      `--user-data-dir=${profile}`,
+      `file://${SRC}`,
+    ],
+    { stdio: "ignore" },
+  );
+
+  let ws;
+  for (let i = 0; i < 100 && !ws; i++) {
+    try {
+      const page = (await (await fetch(`http://127.0.0.1:${port}/json/list`)).json()).find(
+        t => t.type === "page" && t.url.startsWith(`file://${SRC}`),
+      );
+      if (page) ws = new WebSocket(page.webSocketDebuggerUrl);
+    } catch {
+      /* still starting */
+    }
+    if (!ws) await new Promise(r => setTimeout(r, 120));
+  }
+  if (!ws) {
+    proc.kill();
+    throw new Error("Chrome não expôs alvo de depuração");
+  }
+  await new Promise((ok, no) => {
+    ws.onopen = ok;
+    ws.onerror = no;
+  });
+
+  let id = 0;
+  const pending = new Map();
+  ws.onmessage = e => {
+    const m = JSON.parse(e.data);
+    if (m.id && pending.has(m.id)) {
+      pending.get(m.id)(m);
+      pending.delete(m.id);
+    }
+  };
+  const cmd = (method, params = {}) =>
+    new Promise((ok, no) => {
+      const k = ++id;
+      pending.set(k, m => (m.error ? no(new Error(`${method}: ${m.error.message}`)) : ok(m.result)));
+      ws.send(JSON.stringify({ id: k, method, params }));
+    });
+  const evaluate = async expression => {
+    const r = await cmd("Runtime.evaluate", { expression, awaitPromise: true, returnByValue: true });
+    if (r.exceptionDetails) throw new Error(r.exceptionDetails.exception?.description ?? r.exceptionDetails.text);
+    return r.result.value;
+  };
+
+  await cmd("Page.enable");
+  await cmd("Emulation.setDeviceMetricsOverride", { width: W, height: H, deviceScaleFactor: 1, mobile: false });
+  if (FMT === "webm" || FMT === "png-sequence" || has("alpha")) {
+    /* transparent background: only works if the scene doesn't paint the body */
+    await cmd("Emulation.setDefaultBackgroundColorOverride", { color: { r: 0, g: 0, b: 0, a: 0 } });
+  }
+
+  /* wait for the scene to really mount: fonts and its flag */
+  const ready = await evaluate(`(async () => {
+    await document.fonts.ready;
+    for (let i = 0; i < 200; i++) {
+      if (window.__ready === true) return true;
+      await new Promise(r => setTimeout(r, 100));
+    }
+    return false;
+  })()`);
+
+  return {
+    ready,
+    evaluate,
+    async grab(t) {
+      /* write the timeline head and let the compositor settle for TWO
+         frames: with only one, filter/backdrop-filter layers lag behind */
+      await evaluate(`(() => {
+        document.documentElement.style.setProperty("--t", ${t} + "s");
+        return new Promise(r => requestAnimationFrame(() => requestAnimationFrame(() => r(true))));
+      })()`);
+      const { data } = await cmd("Page.captureScreenshot", {
+        format: "png",
+        fromSurface: true,
+        optimizeForSpeed: true,
+      });
+      return Buffer.from(data, "base64");
+    },
+    close() {
+      try {
+        ws.close();
+      } catch {
+        /* already closed */
+      }
+      proc.kill();
+    },
+  };
+}
+
+/* An inline animation-delay or play-state beats calc(--start − --t) and hands
+   the animation back to the wall clock. Frames still look plausible, they just
+   start depending on capture speed. Neutralize and warn. */
+async function determinismGate(s) {
+  const { fixed, running } = await s.evaluate(`(() => {
+    let fixed = 0, running = 0;
+    document.querySelectorAll("[data-anim]").forEach(el => {
+      const d = el.style.animationDelay;           /* an inline delay with --t is legit */
+      if (d && !d.includes("--t")) { el.style.animationDelay = ""; fixed++; }
+      if (el.style.animationPlayState && el.style.animationPlayState !== "paused") { el.style.animationPlayState = ""; fixed++; }
+    });
+    document.querySelectorAll("[data-anim]").forEach(el => { if (getComputedStyle(el).animationPlayState !== "paused") running++; });
+    return { fixed, running };
+  })()`);
+  if (fixed)
+    console.warn(`aviso: ${fixed} estilo(s) inline de animação removidos — a cena estava presa ao relógio, não a --t`);
+  if (running)
+    console.warn(
+      `aviso: ${running} elemento(s) com animation-play-state != paused — o render pode não ser determinístico`,
+    );
+}
+
+const sh = (bin, args) =>
+  new Promise((ok, no) => {
+    const p = spawn(bin, args, { stdio: ["ignore", "inherit", "inherit"] });
+    p.on("exit", c => (c === 0 ? ok() : no(new Error(`${bin} saiu com ${c}`))));
+  });
+
+/* --- run ------------------------------------------------------------------ */
+await mkdir(TMP, { recursive: true });
+const chromePath = await findChrome();
+const sessions = [];
+try {
+  const n = MODE === "video" ? JOBS : 1;
+  sessions.push(...(await Promise.all(Array.from({ length: n }, (_, i) => openSession(chromePath, i)))));
+  if (!sessions[0].ready)
+    console.warn("aviso: a cena não sinalizou window.__ready = true em 20 s; seguindo assim mesmo");
+  for (const s of sessions) await determinismGate(s);
+
+  if (MODE === "still") {
+    const t = AT[0] ?? 0;
+    await writeFile(OUT, await sessions[0].grab(t));
+    console.log(`still em t=${t}s -> ${OUT}`);
+    if (has("measure")) {
+      /* on-screen box (with transform) and effective opacity, including the
+         ancestors': that is what shows at the cut between two scenes.
+         data-continua = legacy name of data-continues */
+      const measurements =
+        await sessions[0].evaluate(`[...document.querySelectorAll("[data-continues],[data-continua]")].map(el => {
+        const r = el.getBoundingClientRect();
+        let opacity = 1;
+        for (let e = el; e; e = e.parentElement) opacity *= +getComputedStyle(e).opacity;
+        return { name: el.dataset.continues ?? el.dataset.continua, x: r.x, y: r.y, w: r.width, h: r.height, opacity };
+      })`);
+      console.log(`MEASUREMENTS ${JSON.stringify(measurements)}`);
+    }
+    /* a page expression, after the still: the caller reads the EVAL line */
+    if (flag("eval", null))
+      console.log(`EVAL ${JSON.stringify((await sessions[0].evaluate(flag("eval", null))) ?? null)}`);
+  } else if (MODE === "frames") {
+    await mkdir(OUT, { recursive: true });
+    for (const [i, t] of AT.entries()) {
+      await writeFile(join(OUT, `q${String(i).padStart(3, "0")}.png`), await sessions[0].grab(t));
+    }
+    console.log(`${AT.length} quadro(s) -> ${OUT}/`);
+  } else if (MODE === "sheet") {
+    const times = AT.length ? AT : [0, 1, 2, 3, 4, 5];
+    for (const [i, t] of times.entries()) {
+      await writeFile(join(TMP, `s${String(i).padStart(3, "0")}.png`), await sessions[0].grab(t));
+    }
+    const cols = Math.min(3, times.length),
+      rows = Math.ceil(times.length / cols);
+    /* tile builds the grid and pads the last row by itself */
+    await sh("ffmpeg", [
+      "-y",
+      "-loglevel",
+      "error",
+      "-framerate",
+      "1",
+      "-i",
+      join(TMP, "s%03d.png"),
+      "-vf",
+      `scale=640:-1,tile=${cols}x${rows}:padding=8:margin=8:color=white`,
+      "-frames:v",
+      "1",
+      OUT,
+    ]);
+    console.log(`folha de contatos (${times.join(", ")}s) -> ${OUT}`);
+  } else {
+    const total = Math.round(DUR * FPS);
+    const seq = FMT === "png-sequence";
+    const frameDir = seq ? OUT : TMP;
+    if (seq) await mkdir(frameDir, { recursive: true });
+    const started = Date.now();
+    let next = 0,
+      done = 0;
+    process.stdout.write(`${total} quadros @ ${FPS}fps, ${sessions.length} Chrome(s) `);
+    await Promise.all(
+      sessions.map(async s => {
+        while (next < total) {
+          const f = next++;
+          await writeFile(
+            join(frameDir, `f${String(f).padStart(5, "0")}.png`),
+            await s.grab(+(FROM + f / FPS).toFixed(6)),
+          );
+          if (++done % 15 === 0) process.stdout.write(".");
+        }
+      }),
+    );
+    console.log(` ok em ${((Date.now() - started) / 1000).toFixed(1)}s`);
+    sessions.forEach(s => s.close());
+    sessions.length = 0;
+
+    if (seq) {
+      console.log(`sequência PNG -> ${OUT}/`);
+    } else if (FMT === "webm") {
+      /* VP9 with alpha: yuva420p keeps transparency */
+      await sh("ffmpeg", [
+        "-y",
+        "-loglevel",
+        "error",
+        "-framerate",
+        String(FPS),
+        "-i",
+        join(TMP, "f%05d.png"),
+        "-c:v",
+        "libvpx-vp9",
+        "-pix_fmt",
+        "yuva420p",
+        "-crf",
+        "24",
+        "-b:v",
+        "0",
+        "-auto-alt-ref",
+        "0",
+        OUT,
+      ]);
+      console.log(`escrito ${OUT}`);
+    } else {
+      /* Top-level -color_* flags are dropped before the H.264 VUI and the
+         file comes out `unknown`; setparams is what writes the bt709 tag. */
+      await sh("ffmpeg", [
+        "-y",
+        "-loglevel",
+        "error",
+        "-framerate",
+        String(FPS),
+        "-i",
+        join(TMP, "f%05d.png"),
+        "-vf",
+        "scale=out_color_matrix=bt709:out_range=tv,format=yuv420p," +
+          "setparams=color_primaries=bt709:color_trc=bt709:colorspace=bt709:range=tv",
+        "-c:v",
+        "libx264",
+        "-crf",
+        "16",
+        "-preset",
+        "slow",
+        "-movflags",
+        "+faststart",
+        OUT,
+      ]);
+      console.log(`escrito ${OUT}`);
+    }
+  }
+} finally {
+  sessions.forEach(s => s.close());
+  /* Chrome may still be writing the profile when it exits: cleanup retries
+     and never fails a render that already finished */
+  await rm(TMP, { recursive: true, force: true, maxRetries: 10, retryDelay: 200 }).catch(e =>
+    console.warn(`aviso: não deu para limpar ${TMP}: ${e.code ?? e.message}`),
+  );
+}

package/tools/runner.mjs

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+/* ============================================================================
+   This Mac as the hosted studio's runner (cloud/studio, docs/specs/phase-1-split-api.md): pairing,
+   status, unpairing and the service that keeps the studio on. The studio (`bun studio.ts`, with
+   cloud.studio in the config) connects with the key this writes into .env (OMNIVIDEO_RUNNER_TOKEN) and
+   picks a new one up within 30 s, no restart. When the cloud refuses its key (not a "Desconectar"), the
+   studio pairs again by itself: it opens the approval page on this Mac.
+
+     node tools/runner.mjs login [--name <nome>] [--no-open]
+                                     pairs this Mac: shows a code, opens the approval page, waits
+     node tools/runner.mjs status [--json]   paired? which Mac? connected now? the service on?
+     node tools/runner.mjs logout            deletes this Mac's key in the cloud and here
+     node tools/runner.mjs service install   the studio as a macOS service: starts at login, restarts if it
+                                             stops, no terminal (log in .runner/studio.log)
+     node tools/runner.mjs service uninstall | restart | status
+
+   Pairing is the device authorization flow (RFC 8628) of the studio's Better Auth: the code lasts
+   10 minutes and is approved by the signed-in user at <studio>/runner/pair. The paired Macs, with
+   "Desconectar", are at <studio>/runner.
+   ============================================================================ */
+
+import { hostname } from "node:os";
+import { spawn } from "node:child_process";
+import { finishPairing, startPairing } from "./lib/pairing.mjs";
+import { cloudSettings, env, runnerStatus, writeEnv } from "./platforms.mjs";
+import { service, serviceInstall, serviceRestart, serviceUninstall } from "./lib/service.mjs";
+
+const KEY = "OMNIVIDEO_RUNNER_TOKEN";
+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);
+};
+
+function studioUrl() {
+  const { url } = cloudSettings().studio;
+  if (!url) fail("falta cloud.studio_url no omnivideo.config.json (o endereço do studio hospedado)");
+  return url;
+}
+
+/** @param {string} url @param {string} path @param {{ method?: string, body?: unknown, token?: string }} [o] */
+async function call(url, path, { method = "POST", body, token } = {}) {
+  const r = await fetch(`${url}${path}`, {
+    method,
+    headers: { "content-type": "application/json", ...(token ? { authorization: `Bearer ${token}` } : {}) },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  const j = await r.json().catch(() => ({}));
+  return { status: r.status, ok: r.ok, body: /** @type {any} */ (j) };
+}
+
+async function login() {
+  const url = studioUrl();
+  const name = flag("name") || hostname().replace(/\.local$/, "");
+  const code = await startPairing(url).catch(e => fail(e.message));
+  console.log(`Código do pareamento: ${code.user_code}`);
+  console.log(`Aprove em: ${code.verification_uri_complete}`);
+  console.log(`(vale ${Math.round(code.expires_in / 60)} min; confira se o código na página é o mesmo)`);
+  if (!args.includes("--no-open") && process.platform === "darwin")
+    spawn("open", [code.verification_uri_complete], { stdio: "ignore", detached: true }).unref();
+  const paired = await finishPairing(url, code, name).catch(e =>
+    fail(`${e.message}; rode de novo node tools/runner.mjs login`),
+  );
+  writeEnv({ [KEY]: paired.key });
+  console.log(`Mac pareado como "${paired.name}". A chave ficou no .env (${KEY}).`);
+  console.log(
+    service().loaded
+      ? "O studio (serviço) conecta sozinho em até 30 s."
+      : "O studio aberto conecta sozinho em até 30 s; para deixá-lo sempre ligado: node tools/runner.mjs service install",
+  );
+}
+
+/* --- the service: the studio kept on by launchd (tools/lib/service.mjs) ------------------ */
+function install() {
+  try {
+    serviceInstall({ log: line => console.log(line) });
+  } catch (e) {
+    fail(String(/** @type {Error} */ (e).message));
+  }
+  console.log("studio ligado como serviço: abre no login e volta sozinho se parar (log em .runner/studio.log)");
+}
+
+function uninstall() {
+  serviceUninstall();
+  console.log(
+    "serviço do studio desligado: o studio hospedado só funciona com o studio aberto à mão (cd studio && bun start)",
+  );
+}
+
+function restart() {
+  if (!service().loaded) fail("o serviço não está ligado: node tools/runner.mjs service install");
+  try {
+    serviceRestart();
+  } catch (e) {
+    fail(String(/** @type {Error} */ (e).message));
+  }
+  console.log("studio reiniciado (depois de um git pull, é assim que o código novo entra)");
+}
+
+const serviceLine = () => {
+  const s = service();
+  if (!s.installed)
+    return "Serviço: desligado (para manter o studio sempre aberto: node tools/runner.mjs service install).";
+  if (!s.loaded) return "Serviço: instalado, mas não carregado: node tools/runner.mjs service install";
+  return `Serviço: ligado${s.pid ? `, studio rodando (pid ${s.pid})` : ", esperando para abrir o studio (veja .runner/studio.log)"}.`;
+};
+
+async function status() {
+  const out = await runnerStatus();
+  if (args.includes("--json")) {
+    const { url, paired, name, online, error } = out;
+    return console.log(JSON.stringify({ url, paired, name, online, error, service: service() }, null, 2));
+  }
+  if (!out.url) return console.log("Studio hospedado: não configurado (cloud.studio_url no config).");
+  console.log(`Studio hospedado: ${out.url}`);
+  console.log(serviceLine());
+  if (!out.hasKey) return console.log("Este Mac: não pareado (node tools/runner.mjs login).");
+  if (!out.paired)
+    return console.log(
+      `Este Mac: a chave não vale mais (${out.error}). O studio aberto pareia de novo sozinho (aprove na página que ele abre), ou: node tools/runner.mjs login`,
+    );
+  console.log(
+    `Este Mac: pareado como "${out.name}", ${out.online ? "conectado agora" : "desconectado (o studio está aberto? veja o serviço acima)"}.`,
+  );
+}
+
+async function logout() {
+  const url = studioUrl();
+  const token = env(KEY);
+  if (!token) return console.log("Este Mac já não está pareado.");
+  const r = await call(url, "/runner/logout", { token });
+  writeEnv({ [KEY]: "" });
+  if (!r.ok && r.status !== 401)
+    fail(`a chave saiu do .env, mas o studio não confirmou (${r.status}: ${r.body?.error ?? "?"})`);
+  console.log("Mac desconectado do studio hospedado. Para voltar: node tools/runner.mjs login");
+}
+
+const [cmd, sub] = args;
+if (cmd === "login") await login();
+else if (cmd === "status") await status();
+else if (cmd === "logout") await logout();
+else if (cmd === "service" && sub === "install") install();
+else if (cmd === "service" && sub === "uninstall") uninstall();
+else if (cmd === "service" && sub === "restart") restart();
+else if (cmd === "service" && (!sub || sub === "status")) console.log(serviceLine());
+else {
+  console.error(
+    "uso: node tools/runner.mjs login [--name <nome>] [--no-open] | status [--json] | logout | service install|uninstall|restart|status",
+  );
+  process.exit(cmd ? 1 : 0);
+}