@crievo/omni 0.0.0-stage → 0.1.1

package/studio/api/services/references.ts

@@ -0,0 +1,269 @@
+/* Reference library (`references.dir` in the config): one dir per
+   reference, with a guide (.md), the measurements.json from `reference.mjs measure`, tokens
+   (.json/.css), frames, sheets and the video. The studio only reads; Claude creates
+   it and writes the guide (api/services/create.ts). Title and essence come from the
+   guide as in `reference.mjs list`. Disabling puts a `.disabled` in the dir:
+   `list` skips the reference, so the motion script doesn't pick it.
+   Deleting moves the dir to the Trash. */
+
+import { readdirSync, statSync, existsSync, realpathSync, writeFileSync, rmSync, renameSync, cpSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve, sep, extname, dirname, basename } from "node:path";
+import { CONFIG, resolvePath, readJson, readText } from "./root";
+import { videoDirs } from "./videos";
+
+const CONFIGURED_LIBRARY_DIR = resolvePath(CONFIG.references.dir);
+export const LIBRARY_DIR: string = existsSync(CONFIGURED_LIBRARY_DIR)
+  ? realpathSync(CONFIGURED_LIBRARY_DIR)
+  : CONFIGURED_LIBRARY_DIR;
+export const REFERENCE_NAME_RE = /^[a-z0-9][a-z0-9-]{0,62}$/;
+
+type FileEntry = { path: string; size: number; mtime: number };
+const IMAGE = /\.(png|jpe?g|webp|gif)$/i;
+const VIDEO = /\.(mp4|mov|webm|m4v)$/i;
+const DISABLED_MARKER = ".disabled";
+
+export function referenceDir(name: string): string | null {
+  if (!REFERENCE_NAME_RE.test(name)) return null;
+  const p = join(LIBRARY_DIR, name);
+  try {
+    return statSync(p).isDirectory() ? p : null;
+  } catch {
+    return null;
+  }
+}
+
+/* root and one level below (frames/, sheets/, reels/) */
+function listFiles(dir: string): FileEntry[] {
+  const list: FileEntry[] = [];
+  const walk = (sub: string, deep: boolean) => {
+    let names: string[];
+    try {
+      names = readdirSync(join(dir, sub))
+        .filter(n => !n.startsWith("."))
+        .sort();
+    } catch {
+      return;
+    }
+    for (const name of names) {
+      const rel = sub ? `${sub}/${name}` : name;
+      let st: ReturnType<typeof statSync>;
+      try {
+        st = statSync(join(dir, rel));
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) {
+        if (deep) walk(rel, false);
+        continue;
+      }
+      list.push({ path: rel, size: st.size, mtime: Math.round(st.mtimeMs) });
+    }
+  };
+  walk("", true);
+  return list;
+}
+
+const mainGuide = (files: FileEntry[]) =>
+  files
+    .filter(a => !a.path.includes("/") && /\.md$/i.test(a.path))
+    .sort((a, b) => Number(b.path === "GUIDE.md") - Number(a.path === "GUIDE.md") || a.path.localeCompare(b.path))[0] ??
+  null;
+
+/* token colors (W3C format: { $type: "color", $value }) when there are no measurements */
+function tokenColors(tokens: any): { hex: string; name: string }[] {
+  const colors: { hex: string; name: string }[] = [];
+  const walk = (o: any, path: string[]) => {
+    if (!o || typeof o !== "object" || colors.length >= 12) return;
+    if (o.$type === "color" && typeof o.$value === "string" && /^#[0-9a-f]{3,8}$/i.test(o.$value)) {
+      colors.push({ hex: o.$value.toUpperCase(), name: path.slice(1).join(".") });
+      return;
+    }
+    for (const [k, v] of Object.entries(o)) if (!k.startsWith("$")) walk(v, [...path, k]);
+  };
+  /* `cor`: legacy group name */
+  walk(tokens?.color ?? tokens?.cor, ["color"]);
+  return colors;
+}
+
+function referenceSummary(name: string, dir: string) {
+  const files = listFiles(dir);
+  const guide = mainGuide(files);
+  const text = guide ? (readText(join(dir, guide.path)) ?? "") : "";
+  const m = readJson<any>(join(dir, "measurements.json"));
+  const tokensFile = files.find(a => !a.path.includes("/") && /tokens.*\.json$/i.test(a.path));
+  const palette = m?.palette
+    ? [...m.palette, ...(m.highlights ?? [])].map((c: any) => ({ hex: c.hex, name: `${c.area_pct}% da tela` }))
+    : tokensFile
+      ? tokenColors(readJson(join(dir, tokensFile.path)))
+      : [];
+  const images = files.filter(a => IMAGE.test(a.path));
+  const cover =
+    images.find(a => a.path === "sheets/contacts.png") ??
+    images.find(a => a.path.startsWith("frames/")) ??
+    images[0] ??
+    null;
+  return {
+    name,
+    enabled: !existsSync(join(dir, DISABLED_MARKER)),
+    title: /^#\s+(.+)$/m.exec(text)?.[1]?.trim() ?? name,
+    essence:
+      /##\s+Ess[êe]ncia\s*\n+([\s\S]*?)(?:\n\n|\n#)/
+        .exec(text)?.[1]
+        ?.replace(/\*\*|__/g, "")
+        .replace(/\s+/g, " ")
+        .trim() ?? null,
+    guide: guide?.path ?? null,
+    measurements: m
+      ? {
+          duration: m.duration,
+          w: m.w,
+          h: m.h,
+          fps: m.fps,
+          shots: m.shots?.count ?? null,
+          hold_pct: m.rhythm?.hold_pct ?? null,
+          strip: m.rhythm?.strip ?? null,
+          step: m.rhythm?.step ?? null,
+          bpm: m.sound?.pulse?.bpm ?? null,
+          source: m.source ?? null,
+        }
+      : null,
+    palette,
+    cover,
+    /* for the card: a frame of the piece (the contact sheet doesn't read small) and the video */
+    frame: images.find(a => a.path.startsWith("frames/")) ?? cover,
+    video:
+      files.filter(a => VIDEO.test(a.path)).sort((a, b) => a.path.split("/").length - b.path.split("/").length)[0] ??
+      null,
+    images: images.length,
+    videos: files.filter(a => VIDEO.test(a.path)).length,
+    updated: Math.max(0, ...files.map(a => a.mtime)),
+  };
+}
+
+export function setReferenceEnabled(
+  name: string,
+  enabled: unknown,
+): { ok: true; output: string } | { ok: false; error: string } {
+  const dir = referenceDir(name);
+  if (!dir) return { ok: false, error: `nenhum estilo visual chamado ${name}` };
+  if (typeof enabled !== "boolean") return { ok: false, error: "enabled precisa ser true ou false" };
+  const marker = join(dir, DISABLED_MARKER);
+  if (enabled) rmSync(marker, { force: true });
+  else writeFileSync(marker, `desligada pelo studio em ${new Date().toISOString()}\n`);
+  return { ok: true, output: enabled ? "ligada" : "desligada" };
+}
+
+/* edits the text of a file the reference already has (.md guide, .json/.css tokens). The previous
+   version stays next to it, hidden (`.<file>.previous`), to undo a mistake. */
+export function saveReferenceText(
+  name: string,
+  path: unknown,
+  text: unknown,
+): { ok: true; output: string } | { ok: false; error: string } {
+  const dir = referenceDir(name);
+  if (!dir) return { ok: false, error: `nenhum estilo visual chamado ${name}` };
+  if (
+    typeof path !== "string" ||
+    !/^[\w.-]+(\/[\w.-]+)?\.(md|json|css)$/i.test(path) ||
+    path.split("/").some(p => p.startsWith("."))
+  ) {
+    return { ok: false, error: "só dá para editar o guia (.md) e os tokens (.json, .css)" };
+  }
+  if (typeof text !== "string") return { ok: false, error: "texto ausente" };
+  if (text.length > 400_000) return { ok: false, error: "texto grande demais (até 400 mil caracteres)" };
+  const abs = resolve(dir, path);
+  if (!abs.startsWith(dir + sep) || !existsSync(abs)) return { ok: false, error: `o estilo visual não tem ${path}` };
+  if (/\.json$/i.test(path)) {
+    try {
+      JSON.parse(text);
+    } catch (e: any) {
+      return { ok: false, error: `JSON inválido: ${e?.message ?? e}` };
+    }
+  }
+  const before = readText(abs) ?? "";
+  if (before === text) return { ok: true, output: "sem mudanças" };
+  writeFileSync(join(dirname(abs), `.${basename(abs)}.previous`), before);
+  const tmp = `${abs}.${process.pid}.tmp`;
+  writeFileSync(tmp, text);
+  renameSync(tmp, abs);
+  return { ok: true, output: "salvo" };
+}
+
+/* to the macOS Trash, with the time in the name if one with the same name exists */
+export function deleteReference(name: string): { ok: true; output: string } | { ok: false; error: string } {
+  const dir = referenceDir(name);
+  if (!dir) return { ok: false, error: `nenhum estilo visual chamado ${name}` };
+  const trash = join(homedir(), ".Trash");
+  if (!existsSync(trash)) return { ok: false, error: `sem Lixeira em ${trash}` };
+  let dest = join(trash, name);
+  if (existsSync(dest)) dest = join(trash, `${name} ${new Date().toISOString().replace(/[:.]/g, "-")}`);
+  try {
+    renameSync(dir, dest);
+  } catch (e: any) {
+    if (e?.code !== "EXDEV") return { ok: false, error: `não deu para mover: ${e?.message ?? e}` };
+    cpSync(dir, dest, { recursive: true });
+    rmSync(dir, { recursive: true, force: true });
+  }
+  return { ok: true, output: `movida para a Lixeira` };
+}
+
+export function listReferences() {
+  let names: string[];
+  try {
+    names = readdirSync(LIBRARY_DIR)
+      .filter(n => !n.startsWith("."))
+      .sort();
+  } catch {
+    return [];
+  }
+  return names.flatMap(n => {
+    const dir = referenceDir(n);
+    return dir ? [referenceSummary(n, dir)] : [];
+  });
+}
+
+/* the videos that cite the reference in scenes.json */
+function usedIn(name: string) {
+  const which: { slug: string; title: string }[] = [];
+  for (const [slug, dir] of videoDirs()) {
+    const c = readJson<any>(join(dir, "scenes.json"));
+    if ((c?.references ?? []).some((r: string) => r === name || r.endsWith(`/${name}`)))
+      which.push({ slug, title: c.title ?? slug });
+  }
+  return which;
+}
+
+export function getReference(name: string) {
+  const dir = referenceDir(name);
+  if (!dir) return null;
+  const files = listFiles(dir);
+  const texts = files
+    .filter(a => /\.(md|json|css)$/i.test(a.path) && a.size < 400_000)
+    .sort(
+      (a, b) =>
+        Number(/\.md$/i.test(b.path)) - Number(/\.md$/i.test(a.path)) ||
+        Number(b.path === "GUIDE.md") - Number(a.path === "GUIDE.md"),
+    )
+    .map(a => ({
+      path: a.path,
+      type: extname(a.path).slice(1).toLowerCase(),
+      text: readText(join(dir, a.path)) ?? "",
+    }));
+  return {
+    ...referenceSummary(name, dir),
+    dir,
+    files: files.filter(a => IMAGE.test(a.path) || VIDEO.test(a.path)),
+    texts,
+    fullMeasurements: readJson(join(dir, "measurements.json")),
+    used_in: usedIn(name),
+  };
+}
+
+/* a file inside a reference, for /ref/<name>/<path> */
+export function referenceFile(name: string, rel: string): string | null {
+  const dir = referenceDir(name);
+  if (!dir) return null;
+  const abs = resolve(dir, rel);
+  return abs.startsWith(dir + sep) ? abs : null;
+}

package/studio/api/services/root.ts

@@ -0,0 +1,60 @@
+/* Paths, config and programs: the same ones the tools/ scripts use. */
+
+import { readFileSync, existsSync, copyFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+
+/* Two roots, as in tools/lib/paths.mjs. CODE_ROOT holds tools/, templates/, docs/ and the .venv: the
+   project dir (studio/api/services → ../../..), or OMNI_CODE_ROOT when this code runs bundled into the
+   compiled `omni` binary, whose own path is /$bunfs/…. ROOT is the workspace (videos/, the config, .env,
+   the dot folders): OMNI_HOME, else OMNIVIDEO_ROOT (tests use a tmp fixture root with its own
+   omnivideo.config.json and videos/), else the code root. */
+export const CODE_ROOT = resolve(process.env.OMNI_CODE_ROOT || resolve(import.meta.dir, "..", "..", ".."));
+export const ROOT = resolve(process.env.OMNI_HOME || process.env.OMNIVIDEO_ROOT || CODE_ROOT);
+/* The Claude dir of the sessions from before the agent accounts (tools/lib/agents.mjs, where
+   ~/.claude is refused): an old turn without `account` ran here. */
+export const CLAUDE_PERSONAL_DIR = join(homedir(), ".claude-personal");
+export const TOOLS_DIR = join(CODE_ROOT, "tools");
+export const QUEUE_DIR = join(ROOT, ".queue");
+/* fresh clone (or workspace) opened before `node tools/setup.mjs`: the config comes from the example */
+if (!existsSync(join(ROOT, "omnivideo.config.json")) && existsSync(join(CODE_ROOT, "omnivideo.config.example.json")))
+  copyFileSync(join(CODE_ROOT, "omnivideo.config.example.json"), join(ROOT, "omnivideo.config.json"));
+export const CONFIG = JSON.parse(readFileSync(join(ROOT, "omnivideo.config.json"), "utf8"));
+/* the project's Python (.venv, created by `node tools/setup.mjs`); without it, the one in the config
+   (the VoiceStudio venv) and, last, the system python3 */
+export const PYTHON: string =
+  [join(CODE_ROOT, ".venv", "bin", "python"), CONFIG.voicestudio?.python ?? ""].find(p => p && existsSync(p)) ??
+  "python3";
+/* config path: relative paths are resolved from the project root */
+export const resolvePath = (p: string) => resolve(ROOT, p.replace(/^~(?=\/|$)/, homedir()));
+/* the node on PATH is the same one the chat uses; without PATH (studio opened outside a
+   shell), the one in the config */
+export const NODE: string = Bun.which("node") ?? CONFIG.premiere?.node ?? "node";
+
+export type RunResult = { stdout: string; stderr: string; code: number };
+
+export async function run(command: string[], env: Record<string, string> = {}): Promise<RunResult> {
+  const p = Bun.spawn(command, { cwd: ROOT, stdout: "pipe", stderr: "pipe", env: { ...process.env, ...env } });
+  const [stdout, stderr, code] = await Promise.all([
+    new Response(p.stdout).text(),
+    new Response(p.stderr).text(),
+    p.exited,
+  ]);
+  return { stdout, stderr, code };
+}
+
+export function readJson<T = any>(file: string): T | null {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+export function readText(file: string): string | null {
+  try {
+    return readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+}

package/studio/api/services/services.ts

@@ -0,0 +1,114 @@
+/* The services the pipeline depends on, observed without touching anything.
+
+   Premiere is seen through the heartbeat the MCP Bridge panel writes every ~1 s.
+   `premiere.mjs status` doesn't fit here: verify_premiere_connection opens
+   Premiere if it is closed, and would send a script to the bridge (which
+   runs one at a time) in the middle of an assembly. */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { CONFIG, ROOT, readJson } from "./root";
+
+/* the same limit as the MCP server (BRIDGE_HEARTBEAT_STALE_MS) */
+const HEARTBEAT_MS = 2500;
+const PRESSURE_LABEL: Record<string, string> = { "1": "normal", "2": "atenção", "4": "crítica" };
+
+async function voicestudio() {
+  try {
+    const r = await fetch(`${CONFIG.voicestudio.url}/health`, { signal: AbortSignal.timeout(2500) });
+    const j = await r.json();
+    return {
+      ok: r.ok && j.status === "ok",
+      url: CONFIG.voicestudio.url,
+      version: j.version ?? null,
+      device: j.device ?? null,
+    };
+  } catch {
+    return { ok: false, url: CONFIG.voicestudio.url, version: null, device: null };
+  }
+}
+
+function premiere() {
+  try {
+    const b = JSON.parse(readFileSync(join(CONFIG.premiere.temp_dir, "bridge-heartbeat.json"), "utf8"));
+    const age = Date.now() - b.t;
+    return { ok: age < HEARTBEAT_MS && b.started === true, started: b.started === true, age_ms: age };
+  } catch {
+    return { ok: false, started: false, age_ms: null };
+  }
+}
+
+/* swap near the limit kills the voice (generation goes past 305 s) */
+function memory() {
+  const r = Bun.spawnSync([
+    "sysctl",
+    "-n",
+    "vm.swapusage",
+    "kern.memorystatus_level",
+    "kern.memorystatus_vm_pressure_level",
+    "hw.memsize",
+  ]);
+  const [swap = "", free, pressure = "", total] = r.stdout.toString().trim().split("\n");
+  const mb = (field: string) => +(new RegExp(`${field} = ([\\d.]+)M`).exec(swap)?.[1] ?? 0);
+  return {
+    swap_total_mb: mb("total"),
+    swap_used_mb: mb("used"),
+    free_pct: +(free ?? 0),
+    pressure: PRESSURE_LABEL[pressure] ?? pressure,
+    total_gb: Math.round(+(total ?? 0) / 2 ** 30),
+  };
+}
+
+/* Voice providers in config order (the first is the default), each ready
+   or with the reason: the same rule as tools/voice.py, without calling the API. Config
+   and .env are reread every time: filling a key doesn't require restarting the studio. */
+const VOICE_PROVIDER_NAMES: Record<string, string> = {
+  fish: "Fish Audio",
+  cartesia: "Cartesia",
+  voicestudio: "VoiceStudio",
+  elevenlabs: "ElevenLabs",
+};
+
+export function readEnvKeys(): Record<string, string> {
+  const vals: Record<string, string> = {};
+  try {
+    for (const line of readFileSync(join(ROOT, ".env"), "utf8").split("\n")) {
+      const m = /^\s*([A-Za-z_][\w]*)\s*=\s*(.*?)\s*$/.exec(line);
+      if (m && !line.trim().startsWith("#")) vals[m[1]] = m[2].replace(/^["']|["']$/g, "");
+    }
+  } catch {
+    /* no .env */
+  }
+  for (const [k, v] of Object.entries(process.env)) if (v) vals[k] = v;
+  return vals;
+}
+
+export function voiceProviders(vs: { ok: boolean }) {
+  const cfg = readJson<any>(join(ROOT, "omnivideo.config.json"))?.voice ?? CONFIG.voice;
+  const env = readEnvKeys();
+  /* with profiles, the voice_id for a video without a choice is the default profile's */
+  const profile = (cfg.profiles ?? []).find((p: any) => p.id === cfg.default_profile);
+  /* the active voice's order (only the providers it has), or the config's without a profile */
+  const ofProfile: string[] = profile
+    ? [...(profile.order ?? []), ...cfg.order].filter(
+        (p: string, i: number, a: string[]) => profile[p] && a.indexOf(p) === i,
+      )
+    : [];
+  const order: string[] = ofProfile.length ? ofProfile : cfg.order;
+  return order.map((id, i) => {
+    let reason: string | null = null;
+    const voiceId = profile ? profile[id] : cfg[id]?.voice_id;
+    if (id === "voicestudio") reason = vs.ok ? null : "app fechado";
+    else if (!env[cfg[id]?.key_env]) reason = `sem chave (${cfg[id]?.key_env} no .env)`;
+    else if (!voiceId)
+      reason = profile
+        ? `o perfil “${profile.name}” não tem voz aqui`
+        : `sem voice_id (voice.${id}.voice_id na config)`;
+    return { id, name: VOICE_PROVIDER_NAMES[id] ?? id, default: i === 0, ready: !reason, reason };
+  });
+}
+
+export async function getServices() {
+  const vs = await voicestudio();
+  return { voicestudio: vs, voices: voiceProviders(vs), premiere: premiere(), memory: memory(), at: Date.now() };
+}