@crievo/omni 0.0.0-stage → 0.1.1

package/studio/api/services/create.ts

@@ -0,0 +1,421 @@
+/* What the UI starts: a new video, a new reference, and chatting with Claude
+   about a video or a reference that already exists. Each one becomes a session
+   (api/services/sessions.ts) with the same request one would make in the chat. */
+
+import { copyFileSync, mkdirSync, writeFileSync, renameSync, existsSync, statSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve, basename, extname, sep } from "node:path";
+import { ROOT, PYTHON, readJson } from "./root";
+import { videoDirs, refreshStatus } from "./videos";
+import { LIBRARY_DIR, REFERENCE_NAME_RE, referenceDir } from "./references";
+import { openSession, replyToSession, latestSessionFor, type ApiResult, type SessionType } from "./sessions";
+import { pauseAfterVoice, pauseNotice } from "./voice-pause";
+import { writeDeliverables, writeNarration, type Deliverable } from "./carousel";
+
+const VIDEOS_DIR = join(ROOT, "videos");
+
+function today() {
+  const d = new Date();
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+
+function slugify(text: string) {
+  return text
+    .normalize("NFD")
+    .replace(/[̀-ͯ]/g, "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, " ")
+    .trim()
+    .split(" ")
+    .filter(Boolean)
+    .slice(0, 5)
+    .join("-")
+    .slice(0, 48)
+    .replace(/-+$/, "");
+}
+
+export type VideoRequest = {
+  request: string;
+  subject?: string;
+  format?: string;
+  duration?: string;
+  reference?: string;
+  voice?: string;
+  voice_profile?: string;
+  /* false: "Sem narração e voz" */
+  narration?: boolean;
+  deliverables?: unknown;
+};
+
+const PROVIDERS = ["fish", "cartesia", "voicestudio"];
+
+/* Voice profile (`voice.profiles` in the config): the chosen id, or "" if the id doesn't exist. */
+function profileIdIfExists(id: unknown): string {
+  const target = String(id ?? "");
+  const profiles: { id: string }[] = readJson<any>(join(ROOT, "omnivideo.config.json"))?.voice?.profiles ?? [];
+  return profiles.some(p => p.id === target) ? target : "";
+}
+
+/* A video's voice: `voice.provider` and `voice.voice_profile` in scenes.json. The other
+   providers in the config order remain as fallback. Changing regenerates the lines
+   on the next `voice` (the requested provider and the profile's voice_id go into the hash). */
+export function chooseVoice(dir: string, choice: { provider?: unknown; voice_profile?: unknown }): ApiResult {
+  const provider = choice.provider == null || choice.provider === "" ? "" : String(choice.provider);
+  const profile =
+    choice.voice_profile == null || choice.voice_profile === "" ? "" : profileIdIfExists(choice.voice_profile);
+  if (provider && !PROVIDERS.includes(provider)) return { ok: false, error: `provider desconhecido: ${provider}` };
+  if (choice.voice_profile && !profile)
+    return { ok: false, error: `o perfil de voz “${choice.voice_profile}” não existe` };
+  if (!provider && !profile) return { ok: false, error: "escolha o provider ou o perfil de voz" };
+  const file = join(dir, "scenes.json");
+  const scenes = readJson<any>(file);
+  if (!scenes)
+    return { ok: false, error: "o vídeo ainda não tem scenes.json: a escolha do pedido vale até ele existir" };
+  const voice = { ...(scenes.voice ?? {}) };
+  if ((!provider || voice.provider === provider) && (!profile || voice.voice_profile === profile))
+    return { ok: true, output: "já era este" };
+  if (provider) voice.provider = provider;
+  if (profile) voice.voice_profile = profile;
+  scenes.voice = voice;
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(scenes, null, 2) + "\n");
+  renameSync(tmp, file);
+  const hasVoice = (scenes.scenes ?? []).some((c: any) => (c.lines ?? []).some((l: any) => l.wav));
+  if (!hasVoice) return { ok: true, output: "gravado" };
+  /* the voice model changed: what comes after the voice is no longer useful, and waits for the new lines */
+  const pause = pauseAfterVoice(dir, ["video-voice"]);
+  return {
+    ok: true,
+    output: `gravado: as falas que já têm voz ficam como estão até você gerar de novo (todas pelo botão, ou uma a uma em cada fala); ${pauseNotice(pause)}`,
+  };
+}
+
+export async function createVideo(p: VideoRequest): Promise<ApiResult & { slug?: string }> {
+  const request = String(p.request ?? "").trim();
+  if (!request) return { ok: false, error: "escreva o pedido: roteiro, tema, material ou link" };
+  /* what the content delivers; with no choice, video (the request from before the carousel) */
+  const deliverables: Deliverable[] = (["video", "carousel"] as const).filter(e =>
+    Array.isArray(p.deliverables) ? p.deliverables.includes(e) : e === "video",
+  );
+  if (!deliverables.length) return { ok: false, error: "escolha vídeo, carrossel ou os dois" };
+  const hasVideo = deliverables.includes("video");
+  const format = p.format === "16:9" ? "16:9" : p.format === "9:16" ? "9:16" : "";
+  const reference = String(p.reference ?? "").trim();
+  if (reference && !referenceDir(reference)) return { ok: false, error: `o estilo visual “${reference}” não existe` };
+  /* "Sem narração e voz": no voice is chosen, and the spoken stages do not run */
+  const silent = p.narration === false;
+  const voice = !silent && PROVIDERS.includes(String(p.voice)) ? String(p.voice) : "";
+  const voiceProfile = silent ? "" : profileIdIfExists(p.voice_profile);
+  const profileName = voiceProfile
+    ? String(
+        (readJson<any>(join(ROOT, "omnivideo.config.json"))?.voice?.profiles ?? []).find(
+          (x: any) => x.id === voiceProfile,
+        )?.name ?? voiceProfile,
+      )
+    : "";
+
+  const base = `${today()}-${slugify(p.subject?.trim() || request) || (hasVideo ? "video" : "carousel")}`;
+  let slug = base;
+  for (let n = 2; existsSync(join(VIDEOS_DIR, slug)) || videoDirs().has(slug); n++) slug = `${base}-${n}`;
+  const dir = join(VIDEOS_DIR, slug);
+  mkdirSync(join(dir, "source"), { recursive: true });
+  writeDeliverables(dir, deliverables);
+  if (hasVideo && silent) writeNarration(dir, false);
+
+  const title = p.subject?.trim() || request.split("\n")[0].slice(0, 80);
+  const choices = [
+    `| entregas | ${deliverables.map(e => (e === "video" ? "vídeo" : "carrossel do Instagram")).join(" e ")} |`,
+    hasVideo && format && `| formato | ${format} |`,
+    p.duration?.trim() && `| duração alvo | ${p.duration.trim()} |`,
+    reference && `| estilo visual | ${reference} |`,
+    hasVideo &&
+      silent &&
+      "| narração e voz | sem narração e voz: pula o roteiro falado, a narração, a voz e a legenda |",
+    hasVideo && voice && `| voz | ${voice} (os outros providers ficam de fallback) |`,
+    hasVideo && voiceProfile && `| perfil de voz | ${profileName} (\`${voiceProfile}\`) |`,
+  ].filter(Boolean);
+  writeFileSync(
+    join(dir, "source", "request.md"),
+    `# ${title}\n\nPedido feito pela tela do studio em ${new Date().toLocaleString("pt-BR")}, palavra por palavra:\n\n` +
+      `${request
+        .split("\n")
+        .map(l => `> ${l}`)
+        .join("\n")}\n` +
+      (choices.length ? `\n## Escolhido na tela\n\n| | |\n|---|---|\n${choices.join("\n")}\n` : ""),
+  );
+
+  /* carousel only: no voice or motion; the av-carousel skill goes up to the export */
+  if (!hasVideo) {
+    const prompt = [
+      "/omnivideo",
+      `Conteúdo novo pedido pela tela do studio, só carrossel do Instagram (sem vídeo). A pasta já existe: videos/${slug} (use este slug, não crie outro).`,
+      `O pedido, palavra por palavra, e o que foi escolhido na tela estão em videos/${slug}/source/request.md: leia antes de tudo e use como o pedido literal do brief (entregas: carrossel).`,
+      reference ? `Use o estilo visual ${reference} no estilo do carrossel.` : "",
+      `Chame a skill av-carousel com \`videos/${slug}\` e vá até o export (carousel.mjs export). Nenhuma etapa do vídeo roda. Pare no export: publicar é pelo botão da tela.`,
+    ]
+      .filter(Boolean)
+      .join("\n");
+    await refreshStatus(slug);
+    const r = openSession("video", slug, dir, title, prompt);
+    return { ...r, slug };
+  }
+
+  const prompt = [
+    "/omnivideo",
+    `Vídeo novo pedido pela tela do studio. A pasta já existe: videos/${slug} (use este slug, não crie outro).`,
+    `O pedido, palavra por palavra, e o que foi escolhido na tela estão em videos/${slug}/source/request.md: leia antes de tudo e use como o pedido literal do brief.`,
+    reference ? `Use o estilo visual ${reference} no roteiro de motion.` : "",
+    !silent && (voice || voiceProfile)
+      ? `No scenes.json, grave "voice": { ${[voice && `"provider": "${voice}"`, voiceProfile && `"voice_profile": "${voiceProfile}"`].filter(Boolean).join(", ")} }.`
+      : "",
+    silent
+      ? `Este vídeo é SEM NARRAÇÃO E VOZ (videos/${slug}/content.json, narration: false). Pule o roteiro falado (etapa 1: não escreva script.md nem abra rodada de aprovação do roteiro), a narração (4), a voz (5) e a legenda (7). Parta do pedido (source/request.md) direto para o roteiro de motion (etapa 2), depois composição (3), render (6) e montagem (8); a duração de cada cena vem da composição (min_duration e os beats em segundos), sem voz. Siga a skill omnivideo, seção "Sem narração e voz".`
+      : "Depois do roteiro, espere a aprovação dele (approval.mjs wait --script, em primeiro plano); saindo com 3, chame a av-script com `ajustar roteiro: «…»` e espere a nova rodada.",
+    "Depois do roteiro de motion, espere a aprovação das cenas (approval.mjs wait, em primeiro plano); a contagem pausa enquanto o usuário edita e volta sozinha; só se ele sair com 4, pare ali: a tela retoma a sessão quando a rodada terminar. O mesmo vale para a saída 4 na aprovação do roteiro.",
+    "Com as cenas aprovadas, siga direto para a composição (etapa 3) e vá até a entrega (etapa 8), sem parar para pedir aprovação.",
+    deliverables.includes("carousel")
+      ? `Este conteúdo também entrega um carrossel do Instagram (content.json): depois do vídeo entregue (etapa 8), chame a av-carousel com \`videos/${slug} do vídeo\` e vá até o export do carrossel.`
+      : "",
+  ]
+    .filter(Boolean)
+    .join("\n");
+  await refreshStatus(slug);
+  const r = openSession("video", slug, dir, title, prompt);
+  return { ...r, slug };
+}
+
+/* a new visual style: a link, photos sent through the upload (their paths in .uploads/), or both. The name is
+   optional: the form does not ask for one, so it comes from the link or the photos (the Omni agent still names it) */
+export type ReferenceRequest = { name?: string; source?: string; images?: string[]; note?: string };
+
+const VIDEO_FILE = /\.(mp4|mov|webm|m4v|mkv|avi|mpe?g)$/i;
+const IMAGE_FILE = /\.(png|jpe?g|webp|heic|avif)$/i;
+const MAX_STYLE_PHOTOS = 12;
+const UPLOADS_DIR = join(ROOT, ".uploads");
+
+/* What the person pastes in the Source field: a link, or a path as Finder and the
+   terminal hand it over (quoted, file://, escaped space, ~/, relative to the
+   project dir, which is where `reference.mjs` resolves from). */
+export function normalizeSource(raw: string): string {
+  let f = raw.trim();
+  const quoted = /^(["'])([\s\S]*)\1$/.exec(f);
+  if (quoted) f = quoted[2].trim();
+  if (/^https?:\/\//i.test(f)) return f;
+  if (/^file:\/\//i.test(f)) {
+    try {
+      return decodeURIComponent(new URL(f).pathname);
+    } catch {
+      return f;
+    }
+  }
+  f = f.replace(/\\(.)/g, "$1");
+  if (f === "~" || f.startsWith("~/")) return join(homedir(), f.slice(1));
+  return resolve(ROOT, f);
+}
+
+/* Video or photo sent from the UI (upload) to serve as a visual style's source.
+   It stays in .uploads/ at the root; `measure` (video) or createReference (photos) copies it to the style's dir. */
+export async function storeUpload(
+  rawName: string,
+  body: ReadableStream | null,
+): Promise<ApiResult & { path?: string }> {
+  let original = "";
+  try {
+    original = decodeURIComponent(rawName);
+  } catch {
+    original = rawName;
+  }
+  const name = basename(original)
+    .normalize("NFD")
+    .replace(/[̀-ͯ]/g, "")
+    .replace(/[^A-Za-z0-9._-]+/g, "-")
+    .replace(/^[.-]+/, "");
+  if (!VIDEO_FILE.test(name) && !IMAGE_FILE.test(name))
+    return {
+      ok: false,
+      error: "o arquivo precisa ser uma foto (png, jpg, webp) ou um vídeo (mp4, mov, webm, m4v, mkv, avi)",
+    };
+  if (!body) return { ok: false, error: "arquivo vazio" };
+  mkdirSync(UPLOADS_DIR, { recursive: true });
+  const dest = join(UPLOADS_DIR, `${Date.now()}-${name}`);
+  try {
+    const bytes = await Bun.write(dest, new Response(body));
+    if (!bytes) throw new Error("arquivo vazio");
+  } catch (e: any) {
+    rmSync(dest, { force: true });
+    return { ok: false, error: `não deu para guardar o upload: ${e?.message ?? e}` };
+  }
+  return { ok: true, path: dest };
+}
+
+/* the name the form does not ask for: from the link (site and id) or the file, else the date; never one that
+   is taken */
+function autoStyleName(source: string): string {
+  let base = "";
+  if (/^https?:\/\//.test(source)) {
+    try {
+      const u = new URL(source);
+      const site = u.hostname.replace(/^www\./, "").split(".")[0];
+      base = `${site}-${u.searchParams.get("v") ?? u.pathname.split("/").filter(Boolean).pop() ?? ""}`;
+    } catch {
+      /* not a URL after all: the date below */
+    }
+  } else if (source) base = basename(source, extname(source));
+  let slug = base
+    .normalize("NFD")
+    .replace(/[̀-ͯ]/g, "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 40)
+    .replace(/-+$/, "");
+  if (!slug) {
+    const d = new Date().toISOString();
+    slug = `estilo-${d.slice(2, 10).replace(/-/g, "")}-${d.slice(11, 16).replace(":", "")}`;
+  }
+  let name = slug;
+  for (let n = 2; referenceDir(name); n++) name = `${slug}-${n}`;
+  return name;
+}
+
+export function createReference(p: ReferenceRequest): ApiResult & { name?: string } {
+  const rawSource = String(p.source ?? "").trim();
+  const source = rawSource ? normalizeSource(rawSource) : "";
+  const images = (p.images ?? []).filter(Boolean);
+  const asked = String(p.name ?? "").trim();
+  if (!source && !images.length)
+    return { ok: false, error: "mande um link (Instagram, YouTube…) ou ao menos uma foto do estilo visual" };
+  if (images.length > MAX_STYLE_PHOTOS)
+    return { ok: false, error: `no máximo ${MAX_STYLE_PHOTOS} fotos por estilo visual` };
+  if (asked && !REFERENCE_NAME_RE.test(asked))
+    return { ok: false, error: "nome: minúsculas, números e hífens (ex.: apura-paraguai)" };
+  if (asked && referenceDir(asked))
+    return { ok: false, error: `já existe o estilo visual “${asked}”: abra ele e peça o ajuste por lá` };
+  if (source && !/^https?:\/\//.test(source)) {
+    let st: ReturnType<typeof statSync>;
+    try {
+      st = statSync(source);
+    } catch {
+      return { ok: false, error: `não achei o arquivo ${source}` };
+    }
+    if (!st.isFile()) return { ok: false, error: `${source} não é um arquivo (aponte para o vídeo, não para a pasta)` };
+    if (!VIDEO_FILE.test(source))
+      return { ok: false, error: `${basename(source)} não parece um vídeo (mp4, mov, webm, m4v, mkv, avi)` };
+  }
+  /* photos only come from the upload: nothing else on the disk is copied into the library */
+  for (const img of images) {
+    const abs = resolve(img);
+    if (!abs.startsWith(UPLOADS_DIR + sep) || !IMAGE_FILE.test(abs) || !existsSync(abs))
+      return { ok: false, error: `a foto ${basename(img)} não foi enviada por aqui: envie de novo` };
+  }
+  const name = asked || autoStyleName(source || (images[0] ? basename(images[0]).replace(/^\d+-/, "") : ""));
+  const dir = join(LIBRARY_DIR, name);
+  const photos: string[] = [];
+  if (images.length) {
+    mkdirSync(join(dir, "images"), { recursive: true });
+    images.forEach((img, i) => {
+      const dest = join(dir, "images", `${String(i + 1).padStart(2, "0")}${extname(img).toLowerCase()}`);
+      copyFileSync(resolve(img), dest);
+      photos.push(dest);
+    });
+  }
+  /* the step by step (measure, Type, curves, guide, proof in code) is the av-reference skill */
+  const prompt = [
+    "/av-reference",
+    `Estilo visual novo para a biblioteca de estilos visuais (${LIBRARY_DIR}), pedido pela tela do studio.`,
+    `nome: ${name}`,
+    source ? `link: ${source}` : "",
+    photos.length ? `fotos (${photos.length}, já na pasta do estilo): ${photos.join(", ")}` : "",
+    source
+      ? `Comece por: node tools/reference.mjs measure ${JSON.stringify(source)} ${name}`
+      : "Não há vídeo: não rode `measure`. Parta das fotos (seção “From photos” da skill): leia cada uma com Read, crie sheets/ e o GUIDE.md a partir de templates/reference.md, e diga no Tipo que ritmo, cortes e curvas não foram medidos.",
+    source && photos.length
+      ? "As fotos entram junto: leia cada uma com Read e use no guia o que elas mostram do estilo (cor, tipografia, composição)."
+      : "",
+    p.note?.trim() ? `O que o usuário quer aprender com ele: ${p.note.trim()}` : "",
+  ]
+    .filter(s => s !== "")
+    .join("\n");
+  const r = openSession("reference", name, dir, name, prompt);
+  /* nothing started: the photos copied for it do not stay as a style without a guide */
+  if (!r.ok && photos.length) rmSync(dir, { recursive: true, force: true });
+  return { ...r, name };
+}
+
+/* A message from the UI for a video or a reference that already exists: resumes the
+   studio's last session, or opens a new one from the files. */
+export function chatWith(type: SessionType, target: string, message: string): ApiResult {
+  const text = String(message ?? "").trim();
+  const last = latestSessionFor(type, target);
+  if (last) return replyToSession(last.id, text || "Continue de onde parou.", text ? "user" : "resume");
+  /* the editor's edit chat: only the editor and render of this video (skill av-editor) */
+  if (type === "edit") {
+    const dir = videoDirs().get(target);
+    if (!dir) return { ok: false, error: "vídeo não encontrado" };
+    if (!text) return { ok: false, error: "diga o que editar" };
+    const prompt = [
+      "/av-editor",
+      `Vídeo videos/${target}, aberto no editor do studio. Comece por \`node tools/editor.mjs show videos/${target}\`.`,
+      `Pedido feito pelo chat do editor: ${text}`,
+    ].join("\n");
+    return openSession("edit", target, dir, `${target} · editor`, prompt, "user");
+  }
+  if (type === "video") {
+    const dir = videoDirs().get(target);
+    if (!dir) return { ok: false, error: "vídeo não encontrado" };
+    const prompt = [
+      "/omnivideo",
+      `Retome o vídeo videos/${target}: \`${PYTHON} tools/omnivideo.py status videos/${target}\` diz a próxima etapa. Se o roteiro espera aprovação, rode \`node tools/approval.mjs wait videos/${target} --script\`; se o roteiro de motion espera aprovação das cenas, rode \`node tools/approval.mjs wait videos/${target}\`.`,
+      text ? `Pedido feito pela tela: ${text}` : "Continue de onde ele parou.",
+    ].join("\n");
+    return openSession("video", target, dir, target, prompt, "resume");
+  }
+  const dir = referenceDir(target);
+  if (!dir) return { ok: false, error: "estilo visual não encontrado" };
+  if (!text) return { ok: false, error: "diga o que fazer no estilo visual" };
+  const prompt = `/av-reference\nEstilo visual ${target}, em ${dir} (guia, measurements.json, sheets, proof; tools/reference.mjs mede, extrai quadros e compara a prova).\nPedido feito pela tela: ${text}`;
+  return openSession("reference", target, dir, target, prompt, "user");
+}
+
+/* Swapping the visual style of a video already started. Claude redoes it
+   (skill omnivideo, Retomar ou refazer, "estilo visual"): motion.md
+   and the scenes.json `references` belong to stage 2. The UI only sends the
+   request to the video session, which resumes (or opens). Empty: Claude picks
+   another one from the library. */
+export async function swapReference(slug: string, reference: string, note: string): Promise<ApiResult> {
+  const dir = videoDirs().get(slug);
+  if (!dir) return { ok: false, error: "vídeo não encontrado" };
+  const scenes = readJson<any>(join(dir, "scenes.json"));
+  if (!scenes || !existsSync(join(dir, "motion.md"))) {
+    return {
+      ok: false,
+      error: "o roteiro de motion ainda não foi escrito: o estilo visual pode ir no pedido, e a etapa 2 usa ele",
+    };
+  }
+  const next = reference.trim();
+  if (next && !referenceDir(next)) return { ok: false, error: `o estilo visual “${next}” não existe` };
+  const current: string[] = scenes.references ?? [];
+  const obs = note.trim();
+  if (next && current.length === 1 && current[0] === next && !obs)
+    return { ok: false, error: "este já é o estilo visual do vídeo: diga no comentário o que mudar nele" };
+  const request = [
+    next
+      ? `Troque o estilo visual deste vídeo para «${next}»${current.length ? `, no lugar de ${current.map(r => `«${r}»`).join(" e ")}` : ""}.`
+      : `Troque o estilo visual deste vídeo: escolha outro dos estilos visuais${current.length ? ` no lugar de ${current.map(r => `«${r}»`).join(" e ")}` : ""}, pela essência de cada uma.`,
+    obs ? `O que o usuário quer no estilo: ${obs}` : "",
+    `Siga a skill omnivideo, Retomar ou refazer, linha "estilo visual": refaça só o que depende do estilo visual, na ordem dela.`,
+  ]
+    .filter(Boolean)
+    .join("\n");
+  const r = chatWith("video", slug, request);
+  if (!r.ok) return r;
+  /* the swap is recorded right away, without waiting for Claude to get there, so the UI can
+     show what is being redone */
+  const swap = { from: current, to: next || null, note: obs || null, requested_at: new Date().toISOString() };
+  mkdirSync(join(dir, "motion"), { recursive: true });
+  const file = join(dir, "motion", "reference-swap.json");
+  writeFileSync(`${file}.${process.pid}.tmp`, JSON.stringify(swap, null, 2) + "\n");
+  renameSync(`${file}.${process.pid}.tmp`, file);
+  await refreshStatus(slug);
+  return { ...r, output: `${r.output} · o motion volta a ser feito com o estilo visual novo` };
+}

package/studio/api/services/events.ts

@@ -0,0 +1,215 @@
+/* Live updates. Watches the video dirs and .queue/ and pushes over SSE only
+   the notice of what changed; the UI rereads what it needs. Queue process
+   liveness and services are checked from time to time, only with someone on the UI. */
+
+import { watch, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import type { Server } from "bun";
+import { QUEUE_DIR, ROOT } from "./root";
+import { videoRoots, refreshStatus, videoDirs } from "./videos";
+import { watchDeadline } from "./approval";
+import { getQueue } from "./queue";
+import { getServices } from "./services";
+import { SESSIONS_DIR, listSessions, onSessionsChange } from "./sessions";
+import { LIBRARY_DIR } from "./references";
+
+type Client = (event: string, data: unknown) => void;
+const clients = new Set<Client>();
+
+function emit(event: string, data: unknown) {
+  for (const c of clients) c(event, data);
+}
+
+/* Omni's settings changed in the admin panel: every open page rereads them (and follows them) */
+export function agentChanged() {
+  emit("agent", {});
+}
+
+/* --- videos --------------------------------------------------------------------
+   A burst of changes (a Premiere export writes the file for minutes) becomes
+   one read every 3 s at most, not one per event. */
+const pending = new Map<string, { timer: ReturnType<typeof setTimeout>; since: number }>();
+function videoChanged(slug: string) {
+  const now = Date.now();
+  const p = pending.get(slug);
+  if (p) clearTimeout(p.timer);
+  const since = p?.since ?? now;
+  const timer = setTimeout(
+    async () => {
+      pending.delete(slug);
+      await refreshStatus(slug);
+      emit("video", { slug });
+      /* the script or scenes countdown restarted, paused or ended: redo the alarms */
+      const dir = videoDirs().get(slug);
+      if (dir) watchDeadline(slug, dir);
+    },
+    now - since > 3000 ? 0 : 400,
+  );
+  pending.set(slug, { timer, since });
+}
+
+/* --- queue ------------------------------------------------------------------------ */
+let lastQueue = "";
+function checkQueue() {
+  const q = getQueue();
+  const text = JSON.stringify(q);
+  if (text !== lastQueue) {
+    lastQueue = text;
+    emit("queue", q);
+  }
+}
+let queueScheduled: ReturnType<typeof setTimeout> | null = null;
+function scheduleQueueCheck() {
+  if (queueScheduled) return;
+  queueScheduled = setTimeout(() => {
+    queueScheduled = null;
+    checkQueue();
+  }, 120);
+}
+
+/* --- Claude sessions and references ---------------------------------------------
+   A turn's jsonl grows with every message: the list goes out at most every
+   600 ms. Process liveness is checked from time to time, like the queue's. */
+let lastSessions = "";
+function checkSessions() {
+  const s = listSessions();
+  const text = JSON.stringify(s);
+  if (text !== lastSessions) {
+    lastSessions = text;
+    emit("sessions", s);
+  }
+}
+let sessionsScheduled: ReturnType<typeof setTimeout> | null = null;
+function scheduleSessionsCheck() {
+  if (sessionsScheduled) return;
+  sessionsScheduled = setTimeout(() => {
+    sessionsScheduled = null;
+    checkSessions();
+  }, 600);
+}
+
+const changedRefs = new Set<string>();
+let refsScheduled: ReturnType<typeof setTimeout> | null = null;
+function referenceChanged(name: string) {
+  changedRefs.add(name);
+  if (refsScheduled) clearTimeout(refsScheduled);
+  refsScheduled = setTimeout(() => {
+    refsScheduled = null;
+    for (const n of changedRefs) emit("reference", { name: n });
+    changedRefs.clear();
+  }, 500);
+}
+
+/* --- omnichat -----------------------------------------------------------------
+   The rule and record of a video (videos/<slug>/), of its carousel (videos/<slug>/carousel/) or of an outside post
+   (.omnichat/posts/<code>/), publication.json (the Reel went up) and the account pause:
+   the omnichat page rereads. The agent's lock and log, which change every minute, don't. */
+const OMNICHAT_FILES = /^(omnichat|omnichat-record|publication)\.json$/;
+const autoPending = new Map<string, ReturnType<typeof setTimeout>>();
+function omnichatChanged(data: { slug?: string; code?: string }) {
+  const key = data.slug ? `v:${data.slug}` : data.code ? `p:${data.code}` : "account";
+  clearTimeout(autoPending.get(key));
+  autoPending.set(
+    key,
+    setTimeout(() => {
+      autoPending.delete(key);
+      emit("omnichat", data);
+    }, 300),
+  );
+}
+
+/* --- analytics -------------------------------------------------------------------
+   A Reel's metrics (videos/<slug>/metrics.json, which the agent rewrites on every
+   read), its analysis, the account snapshot (.metrics/account.json) and channel/
+   (playbook and analyses): the Analytics page rereads. The agent's lock and log don't. */
+const ANALYTICS_FILES = /^(metrics\.json|analysis\.md|publication\.json)$/;
+let analyticsScheduled: ReturnType<typeof setTimeout> | null = null;
+function analyticsChanged() {
+  if (analyticsScheduled) clearTimeout(analyticsScheduled);
+  analyticsScheduled = setTimeout(() => {
+    analyticsScheduled = null;
+    emit("analytics", {});
+  }, 500);
+}
+
+export function startWatching() {
+  for (const root of videoRoots) {
+    if (!existsSync(root)) continue;
+    watch(root, { recursive: true }, (_, name) => {
+      const path = String(name ?? "");
+      const slug = path.split("/")[0];
+      if (!slug || slug.startsWith(".") || path.endsWith(".DS_Store")) return;
+      videoChanged(slug);
+      const rest = path.slice(slug.length + 1);
+      /* the content's carousel has its own rule, in <slug>/carousel/ */
+      if (OMNICHAT_FILES.test(rest) || OMNICHAT_FILES.test(rest.replace(/^carousel\//, ""))) omnichatChanged({ slug });
+      if (ANALYTICS_FILES.test(path.slice(slug.length + 1))) analyticsChanged();
+    });
+  }
+  const OMNICHAT_DIR = join(ROOT, ".omnichat");
+  mkdirSync(OMNICHAT_DIR, { recursive: true });
+  watch(OMNICHAT_DIR, { recursive: true }, (_, name) => {
+    const path = String(name ?? "");
+    const [dir, code, file] = path.split("/");
+    if (dir === "posts" && code && (!file || OMNICHAT_FILES.test(file))) omnichatChanged({ code });
+    else if (path === "pause.json") omnichatChanged({});
+  });
+  for (const dir of [join(ROOT, ".metrics"), join(ROOT, "channel")]) {
+    mkdirSync(dir, { recursive: true });
+    watch(dir, { recursive: true }, (_, name) => {
+      const path = String(name ?? "");
+      if (path.endsWith(".md") || path === "account.json") analyticsChanged();
+    });
+  }
+  mkdirSync(QUEUE_DIR, { recursive: true });
+  watch(QUEUE_DIR, scheduleQueueCheck);
+  mkdirSync(SESSIONS_DIR, { recursive: true });
+  watch(SESSIONS_DIR, { recursive: true }, scheduleSessionsCheck);
+  onSessionsChange(scheduleSessionsCheck);
+  if (existsSync(LIBRARY_DIR)) {
+    watch(LIBRARY_DIR, { recursive: true }, (_, name) => {
+      const ref = String(name ?? "").split("/")[0];
+      if (ref && !ref.startsWith(".") && !String(name).endsWith(".DS_Store")) referenceChanged(ref);
+    });
+  }
+  setInterval(() => {
+    if (clients.size) checkQueue();
+  }, 2000);
+  setInterval(() => {
+    if (clients.size) checkSessions();
+  }, 3000);
+  setInterval(async () => {
+    if (clients.size) emit("services", await getServices());
+  }, 4000);
+}
+
+export function eventsStream(req: Request, server: Server<unknown>): Response {
+  /* the SSE stays open; Bun's default drops an idle connection after 10 s */
+  server.timeout(req, 0);
+  const encoder = new TextEncoder();
+  let client: Client = () => {};
+  let ping: ReturnType<typeof setInterval>;
+  const leave = () => {
+    clients.delete(client);
+    clearInterval(ping);
+  };
+  const body = new ReadableStream({
+    start(ctrl) {
+      client = (event, data) => {
+        try {
+          ctrl.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`));
+        } catch {
+          leave();
+        }
+      };
+      clients.add(client);
+      client("queue", getQueue());
+      client("sessions", listSessions());
+      getServices().then(s => client("services", s));
+      ping = setInterval(() => client("ping", Date.now()), 15_000);
+      req.signal.addEventListener("abort", leave);
+    },
+    cancel: leave,
+  });
+  return new Response(body, { headers: { "content-type": "text/event-stream", "cache-control": "no-cache" } });
+}

package/studio/api/services/media.ts

@@ -0,0 +1,32 @@
+/* Which file a media URL points to: a video's file (/media), a reference's (/ref), a stored voice
+   sample or original recording. Null when the path is not allowed or climbs out of its dir. */
+
+import { resolve, sep } from "node:path";
+import { videoDirs } from "./videos";
+import { referenceFile } from "./references";
+import { CLONES_DIR } from "./clone";
+import { SAMPLES_DIR } from "./settings";
+
+/* what a video's or reference's dir may serve */
+const ALLOWED_MEDIA = /\.(png|jpe?g|webp|gif|mp4|mov|webm|wav|mp3|m4a|srt|json|md|txt)$/i;
+
+/* /media/<slug>/<path> */
+export function videoMediaFile(slug: string, rel: string): string | null {
+  const dir = videoDirs().get(slug);
+  if (!dir || !ALLOWED_MEDIA.test(rel)) return null;
+  const abs = resolve(dir, rel);
+  return abs.startsWith(dir + sep) ? abs : null;
+}
+
+/* /ref/<name>/<path>: media plus the reference's CSS */
+export function referenceMediaFile(name: string, rel: string): string | null {
+  if (!ALLOWED_MEDIA.test(rel) && !/\.css$/i.test(rel)) return null;
+  return referenceFile(name, rel);
+}
+
+/* /api/voice-original/<clone>: the recording a clone was made from */
+export const originalWavFile = (clone: string) =>
+  /^[a-z0-9-]+$/.test(clone) ? resolve(CLONES_DIR, clone, "original.wav") : null;
+
+/* /api/voice-sample/<file>: a profile's generated sample */
+export const sampleWavFile = (file: string) => (/^[a-z0-9-]+\.wav$/.test(file) ? resolve(SAMPLES_DIR, file) : null);