@crievo/omni 0.1.7 → 0.1.9

package/tools/lib/self-update.mjs

@@ -0,0 +1,122 @@
+/* The studio service updating itself. When the hosted studio and this machine speak different protocols the hub
+   closes the runner's socket with UPGRADE (tools/lib/channel.mjs), and which side is old is not in a form the runner
+   can read. It doesn't need to: it asks the npm registry whether a version of the CLI newer than the one it runs
+   exists. If so, this machine is the one behind, and `npx -y @crievo/omni@<latest> up` does what a session's hook
+   would: installs the new copy under ~/.omni/app, swaps the studio service onto it and restarts it
+   (tools/lib/up.mjs). If not, the hosted studio is the old side (or npm hasn't published yet) and there is nothing
+   to do here but wait: the runner looks again in a minute.
+
+   Never on a development checkout (`.git` in the code root: `omni up` never rewires one), never without the
+   plugin's login (a legacy key machine has no `up` to run), never while the setup is running, and at most once an
+   hour. Everything the outside world does (the registry, the process) is injected for the tests. Messages in
+   Portuguese: they reach the log as they are. */
+
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, openSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { PACKAGE } from "./cli.mjs";
+import { OMNI_DIR, depsEnv } from "./deps.mjs";
+import { CODE_ROOT, DATA_ROOT } from "./paths.mjs";
+
+const REGISTRY = "https://registry.npmjs.org";
+export const UPDATE_EVERY_MS = 60 * 60_000;
+
+/** the version a code root runs, or null (a checkout has no package.json of the CLI)  @param {string} codeRoot */
+export function versionOf(codeRoot) {
+  try {
+    return String(JSON.parse(readFileSync(join(codeRoot, "package.json"), "utf8")).version ?? "") || null;
+  } catch {
+    return null;
+  }
+}
+
+/** whether `a` is a later release than `b` (major.minor.patch; a pre-release tag counts as the release it precedes)
+ *  @param {string} a @param {string} b */
+export function isNewer(a, b) {
+  const n = (/** @type {string} */ v) =>
+    v
+      .split("-")[0]
+      .split(".")
+      .map(x => Number.parseInt(x, 10) || 0);
+  const [x, y] = [n(a), n(b)];
+  for (let i = 0; i < 3; i++) if ((x[i] ?? 0) !== (y[i] ?? 0)) return (x[i] ?? 0) > (y[i] ?? 0);
+  /* same numbers: "1.2.3" is later than "1.2.3-beta" */
+  return !a.includes("-") && b.includes("-");
+}
+
+/** the newest published version of the CLI  @param {{ fetch?: typeof fetch }} [o] */
+export async function latestVersion({ fetch: doFetch = fetch } = {}) {
+  const r = await doFetch(`${REGISTRY}/${PACKAGE.replace("/", "%2F")}/latest`, {
+    headers: { accept: "application/json" },
+    signal: AbortSignal.timeout(8_000),
+  });
+  if (!r.ok) throw new Error(`o npm respondeu ${r.status}`);
+  const v = String(/** @type {any} */ (await r.json()).version ?? "");
+  if (!/^\d+\.\d+\.\d+/.test(v)) throw new Error("o npm não disse a versão");
+  return v;
+}
+
+/** runs `npx -y <spec> up` in a process of its own, so the service swapping itself doesn't take it down with it;
+ *  its output goes to ~/.omni/update.log  @param {{ spec: string, dataRoot: string }} o */
+export function startUpdate({ spec, dataRoot }) {
+  mkdirSync(OMNI_DIR, { recursive: true });
+  const out = openSync(join(OMNI_DIR, "update.log"), "a");
+  const win = process.platform === "win32";
+  spawn(win ? "npx.cmd" : "npx", ["-y", spec, "up"], {
+    detached: true,
+    windowsHide: true,
+    /* npx is a .cmd on Windows, which Node only spawns through a shell */
+    shell: win,
+    stdio: ["ignore", out, out],
+    env: { ...process.env, ...depsEnv(), OMNI_HOME: dataRoot },
+  }).unref();
+}
+
+/**
+ * @param {{
+ *   codeRoot?: string,
+ *   dataRoot?: string,
+ *   fetch?: typeof fetch,
+ *   run?: (o: { spec: string, dataRoot: string }) => void,
+ *   log?: (line: string) => void,
+ *   now?: () => number,
+ *   everyMs?: number,
+ *   busy?: () => boolean,
+ *   loggedIn?: () => boolean,
+ * }} [o]
+ * @returns {() => Promise<"dev" | "login" | "busy" | "wait" | "offline" | "current" | "started">} one look: what it did
+ */
+export function createSelfUpdater({
+  codeRoot = CODE_ROOT,
+  dataRoot = DATA_ROOT,
+  fetch: doFetch = fetch,
+  run = startUpdate,
+  log = () => {},
+  now = Date.now,
+  everyMs = UPDATE_EVERY_MS,
+  busy = () => false,
+  loggedIn = () => true,
+} = {}) {
+  let lastStart = 0;
+  return async function update() {
+    if (existsSync(join(codeRoot, ".git"))) return "dev";
+    if (!loggedIn()) return "login";
+    if (busy()) return "busy";
+    if (lastStart && now() - lastStart < everyMs) return "wait";
+    const current = versionOf(codeRoot);
+    let latest;
+    try {
+      latest = await latestVersion({ fetch: doFetch });
+    } catch (e) {
+      log(`aviso: não consegui ver se há versão nova do Omni (${/** @type {Error} */ (e).message})`);
+      return "offline";
+    }
+    /* no newer version: this machine is already the latest, so the hosted studio is the old side, or npm is yet to
+       publish what it was deployed with */
+    if (!current || !isNewer(latest, current)) return "current";
+    lastStart = now();
+    log(`aviso: atualizando o Omni ${current} → ${latest}: esta máquina está atrás do studio hospedado`);
+    run({ spec: `${PACKAGE}@${latest}`, dataRoot });
+    return "started";
+  };
+}

package/tools/lib/setup-progress.mjs

@@ -0,0 +1,315 @@
+/* The first-time setup, as the user watches it. After the plugin's login the CLI prepares the computer (the
+   workspace, a stable copy of the app, the programs the pipeline runs, the studio service), and the hosted
+   page shows each piece as a vertical stepper with a loading circle that turns into a check
+   (studio/web/components/SetupSteps.tsx). The page can't ask this computer while the studio isn't connected
+   to it, so the CLI writes the progress to the user's own cloud, which the page reads
+   (`setup` in the config of GET /api/cloud/config; cloud/studio/src/cloud.mjs). The same record is kept in
+   ~/.omni/setup.json.
+
+   The steps are named for what they are for, never for the program that does it: the user reads "Configuração
+   para extrair o estilo visual", not "yt-dlp". Their ids are the ones tools/lib/deps.mjs reports (video,
+   render, voice, style). Labels reach the user as they are: Portuguese.
+
+   The reporter never throws and never waits on the network for long: a failed update is dropped, the next
+   one carries the whole record anyway. The clock, fetch, the token and the file are injected for the tests. */
+
+import { mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { OMNI_DIR } from "./deps.mjs";
+
+export const SETUP_FILE = join(OMNI_DIR, "setup.json");
+const LOCK_FILE = join(OMNI_DIR, "setup.lock");
+/* a setup that holds the lock for longer than this is a dead one */
+const LOCK_STALE_MS = 60 * 60_000;
+const PUT_TIMEOUT_MS = 8_000;
+
+/** @typedef {"pending" | "running" | "done" | "error"} StepState */
+/** @typedef {{ id: string, label: string, detail: string, state: StepState, error?: string }} SetupStep */
+/** @typedef {{ v: 1, state: "running" | "done" | "error", device: string, started_at: number, updated_at: number, steps: SetupStep[], watching_at?: number, handled?: string }} SetupRecord
+ *  `watching_at`: the last time the process that is waiting for a retry looked (the page offers "Tentar de novo" only
+ *  while it is recent); `handled`: the id of the last retry request it dealt with */
+
+/** every piece of the setup, in the order it runs; what each is for, in the user's words */
+export const SETUP_STEPS = [
+  {
+    id: "workspace",
+    label: "Criando a sua pasta de trabalho",
+    detail: "Onde ficam os seus vídeos e as suas configurações, no seu computador.",
+  },
+  {
+    id: "app",
+    label: "Instalando o Omni neste computador",
+    detail: "Uma cópia que se atualiza sozinha e fica pronta para o Claude usar.",
+  },
+  {
+    id: "video",
+    label: "Configuração para montar e exportar o vídeo",
+    detail: "Junta as cenas, a voz e as legendas no arquivo final.",
+  },
+  {
+    id: "render",
+    label: "Configuração para renderizar as animações",
+    detail: "Transforma o motion de cada cena em vídeo.",
+  },
+  {
+    id: "voice",
+    label: "Configuração para a voz, o tempo e as legendas",
+    detail: "Mede a fala e deixa cada cena e cada legenda no tempo certo.",
+  },
+  {
+    id: "style",
+    label: "Configuração para extrair o estilo visual",
+    detail: "Lê um vídeo ou um link de referência e aprende o estilo dele.",
+  },
+  {
+    id: "studio",
+    label: "Conectando este computador ao studio",
+    detail: "Para o site conversar com o Claude e com os seus arquivos daqui.",
+  },
+];
+
+/** a fresh record: every step waiting  @param {{ device: string, now?: () => number }} o @returns {SetupRecord} */
+export function newSetup({ device, now = Date.now }) {
+  const t = now();
+  return {
+    v: 1,
+    state: "running",
+    device,
+    started_at: t,
+    updated_at: t,
+    steps: SETUP_STEPS.map(s => ({ ...s, state: "pending" })),
+  };
+}
+
+/** The record after a step changed (pure). The whole setup is done when every step is, and it fails when one
+ *  did and none is left running.  @param {SetupRecord} rec @param {string} id @param {StepState} state
+ *  @param {string} [error] @param {() => number} [now] @returns {SetupRecord} */
+export function withStep(rec, id, state, error, now = Date.now) {
+  const steps = rec.steps.map(s => {
+    if (s.id !== id) return s;
+    const { error: _old, ...rest } = s;
+    return state === "error" ? { ...rest, state, error: String(error ?? "").slice(0, 300) } : { ...rest, state };
+  });
+  const all = steps.every(s => s.state === "done");
+  const failed = steps.some(s => s.state === "error") && !steps.some(s => s.state === "running");
+  return { ...rec, steps, state: all ? "done" : failed ? "error" : "running", updated_at: now() };
+}
+
+/**
+ * Keeps a record and tells the cloud (and the file) every time it changes.
+ * @param {{
+ *   studioUrl: string,
+ *   token: () => Promise<string | null>,
+ *   device: string,
+ *   fetch?: typeof fetch,
+ *   now?: () => number,
+ *   file?: string,
+ * }} o
+ */
+export function createReporter({
+  studioUrl,
+  token,
+  device,
+  fetch: doFetch = fetch,
+  now = Date.now,
+  file = SETUP_FILE,
+}) {
+  let record = newSetup({ device, now });
+  /* updates go one after the other, so the last one written is the last one the cloud keeps */
+  let chain = Promise.resolve();
+
+  const push = () => {
+    const body = JSON.stringify({ setup: record });
+    try {
+      mkdirSync(dirname(file), { recursive: true });
+      writeFileSync(file, `${JSON.stringify(record, null, 2)}\n`);
+    } catch {
+      /* the cloud copy is the one the page reads */
+    }
+    chain = chain.then(async () => {
+      try {
+        const t = await token();
+        if (!t) return;
+        await doFetch(`${studioUrl}/api/cloud/config`, {
+          method: "PUT",
+          headers: { authorization: `Bearer ${t}`, "content-type": "application/json" },
+          body,
+          signal: AbortSignal.timeout(PUT_TIMEOUT_MS),
+        });
+      } catch {
+        /* offline or the studio is down: the next update carries everything */
+      }
+    });
+  };
+
+  return {
+    /** the record as it is now */
+    get record() {
+      return record;
+    },
+    /** begins again with every step waiting (also tells the cloud) */
+    start() {
+      record = newSetup({ device, now });
+      push();
+    },
+    /** @param {string} id @param {StepState} state @param {string} [error] */
+    step(id, state, error) {
+      record = withStep(record, id, state, error, now);
+      push();
+    },
+    /** the process is waiting for a retry request: says so, so the page knows someone is there */
+    beat() {
+      record = { ...record, watching_at: now(), updated_at: now() };
+      push();
+    },
+    /** the retry request with this id has been dealt with @param {string} id */
+    handled(id) {
+      record = { ...record, handled: id, updated_at: now() };
+      push();
+    },
+    /** nobody is waiting any more */
+    stopWatching() {
+      const { watching_at: _gone, ...rest } = record;
+      record = { ...rest, updated_at: now() };
+      push();
+    },
+    /** waits for the last update to leave */
+    async flush() {
+      await chain;
+    },
+  };
+}
+
+/** @typedef {ReturnType<typeof createReporter>} Reporter */
+
+/** a reporter that tells no one (the hook, the tests)  @type {Reporter} */
+export const silentReporter = {
+  get record() {
+    return /** @type {SetupRecord} */ (newSetup({ device: "" }));
+  },
+  start() {},
+  step() {},
+  beat() {},
+  handled() {},
+  stopWatching() {},
+  async flush() {},
+};
+
+/* --- retrying a step from the page ------------------------------------------------------------- */
+
+/* the page asks for a retry by writing this key of the user's cloud config (the browser's session may write
+   there); the process that ran the setup, still alive after a failure, reads it */
+export const RETRY_KEY = "setup_retry";
+const RETRY_STEPS = new Set([...SETUP_STEPS.map(s => s.id), "all"]);
+
+/** A retry request, if it is well formed: an id and a step this setup knows (or "all"). Nothing else the page
+ *  could write is ever run.  @param {unknown} v @returns {{ id: string, step: string } | null} */
+export function parseRetry(v) {
+  if (!v || typeof v !== "object") return null;
+  const { id, step } = /** @type {Record<string, unknown>} */ (v);
+  return typeof id === "string" && id.length > 0 && id.length <= 64 && typeof step === "string" && RETRY_STEPS.has(step)
+    ? { id, step }
+    : null;
+}
+
+/**
+ * After a failed setup, stays alive and does what the page asks: "Tentar de novo" on a step (or on all of them).
+ * It looks every few seconds, tells the page it is there (`watching_at`), and gives up after a quiet half hour or
+ * once the setup is done. Never throws: a studio that doesn't answer is just a look that found nothing.
+ * @param {{
+ *   studioUrl: string,
+ *   token: () => Promise<string | null>,
+ *   reporter: ReturnType<typeof createReporter>,
+ *   run: (step: string) => Promise<void>,
+ *   fetch?: typeof fetch,
+ *   now?: () => number,
+ *   sleep?: (ms: number) => Promise<void>,
+ *   pollMs?: number, beatMs?: number, idleMs?: number,
+ * }} o
+ */
+export async function watchRetries({
+  studioUrl,
+  token,
+  reporter,
+  run,
+  fetch: doFetch = fetch,
+  now = Date.now,
+  sleep = ms => new Promise(r => setTimeout(r, ms)),
+  pollMs = 5_000,
+  beatMs = 15_000,
+  idleMs = 30 * 60_000,
+}) {
+  const look = async () => {
+    try {
+      const t = await token();
+      if (!t) return null;
+      const r = await doFetch(`${studioUrl}/api/cloud/config`, {
+        headers: { authorization: `Bearer ${t}` },
+        signal: AbortSignal.timeout(PUT_TIMEOUT_MS),
+      });
+      return r.ok ? parseRetry(/** @type {any} */ (await r.json()).config?.[RETRY_KEY]) : null;
+    } catch {
+      return null;
+    }
+  };
+  let seen = reporter.record.handled ?? "";
+  let lastBeat = now();
+  let lastWork = now();
+  reporter.beat();
+  while (reporter.record.state === "error" && now() - lastWork < idleMs) {
+    await sleep(pollMs);
+    const req = await look();
+    if (req && req.id !== seen) {
+      seen = req.id;
+      try {
+        await run(req.step);
+      } catch {
+        /* the step reports its own failure */
+      }
+      reporter.handled(req.id);
+      lastWork = lastBeat = now();
+    } else if (now() - lastBeat >= beatMs) {
+      reporter.beat();
+      lastBeat = now();
+    }
+  }
+  reporter.stopWatching();
+  await reporter.flush();
+}
+
+/* --- the lock: one setup at a time --------------------------------------------------------- */
+
+const alive = (/** @type {number} */ pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    /* EPERM: it exists and isn't ours */
+    return /** @type {NodeJS.ErrnoException} */ (e).code === "EPERM";
+  }
+};
+
+/** whether a setup is running now: the lock names a live process and is not too old  @param {string} [lock] */
+export function setupRunning(lock = LOCK_FILE) {
+  try {
+    const pid = Number(readFileSync(lock, "utf8"));
+    return Number.isInteger(pid) && pid > 0 && alive(pid) && Date.now() - statSync(lock).mtimeMs < LOCK_STALE_MS;
+  } catch {
+    return false;
+  }
+}
+
+/** Takes the lock for this process, or returns null when another setup holds it.
+ *  @param {string} [lock] @returns {(() => void) | null} the release */
+export function acquireSetupLock(lock = LOCK_FILE) {
+  if (setupRunning(lock)) return null;
+  mkdirSync(dirname(lock), { recursive: true });
+  writeFileSync(lock, String(process.pid));
+  return () => {
+    try {
+      if (Number(readFileSync(lock, "utf8")) === process.pid) rmSync(lock, { force: true });
+    } catch {
+      /* already gone */
+    }
+  };
+}