@crievo/omni 0.0.0-stage → 0.1.0

package/studio/api/services/videos.ts

@@ -0,0 +1,418 @@
+/* Videos are the dirs in videos/ (and in the dirs passed with --videos).
+   Stage and next come from `omnivideo.py status --json`, beat times from
+   tools/timing.mjs: the studio does not redo the tools' math. The rest is read
+   from the video's files, which are the source of truth. */
+
+import { readdirSync, existsSync, statSync, realpathSync } from "node:fs";
+import { join, relative, resolve, basename } from "node:path";
+import { ROOT, TOOLS_DIR, PYTHON, run, readJson, readText } from "./root";
+import { listTickets, type Ticket, type Queue } from "./queue";
+import { loadVideo, beatTime } from "../../../tools/timing.mjs";
+import { scenesApprovalOf, scriptApprovalOf } from "./approval";
+import { deliverables, narration, carouselSummary, carouselDetail } from "./carousel";
+
+type FileEntry = { path: string; size: number; mtime: number };
+
+export const videoRoots: string[] = [];
+
+/* real path: the queue records the video dir with links resolved (on macOS,
+   /tmp is /private/tmp), and that is how the UI ties a task to a video */
+export function addVideoRoot(dir: string) {
+  const abs = resolve(dir);
+  videoRoots.push(existsSync(abs) ? realpathSync(abs) : abs);
+}
+addVideoRoot(join(ROOT, "videos"));
+
+/* slug → dir. A content dir is one with scenes.json, brief.md or script.md,
+   the source/request.md of a UI request, content.json or a carousel */
+export function videoDirs(): Map<string, string> {
+  const found = new Map<string, string>();
+  for (const root of videoRoots) {
+    let names: string[];
+    try {
+      names = readdirSync(root).sort();
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      const dir = join(root, name);
+      if (name.startsWith(".") || found.has(name)) continue;
+      if (
+        ["scenes.json", "brief.md", "script.md", "source/request.md", "content.json", "carousel/carousel.json"].some(
+          f => existsSync(join(dir, f)),
+        )
+      )
+        found.set(name, dir);
+    }
+  }
+  return found;
+}
+
+/* --- status ------------------------------------------------------------------
+   One `status --json` per video, cached until one of its files changes. If it
+   changes in the middle of a read, reads again when that one ends. */
+type PipelineStatus = {
+  stages: { id: string; number: string; name: string; ok: boolean; detail: string | null }[];
+  next: { id: string; name: string } | null;
+  ready: boolean;
+  total_duration: number | null;
+  warnings: string[];
+};
+type StatusEntry = { data?: PipelineStatus; error?: string; reading?: Promise<void>; dirty?: boolean };
+const statuses = new Map<string, StatusEntry>();
+
+let inUse = 0;
+const waitList: (() => void)[] = [];
+async function limitConcurrency<T>(fn: () => Promise<T>): Promise<T> {
+  /* three at a time: each status opens a Python and one ffprobe per scene */
+  if (inUse >= 3) await new Promise<void>(r => waitList.push(r));
+  inUse++;
+  try {
+    return await fn();
+  } finally {
+    inUse--;
+    waitList.shift()?.();
+  }
+}
+
+export function refreshStatus(slug: string): Promise<void> {
+  const e = statuses.get(slug) ?? {};
+  statuses.set(slug, e);
+  if (e.reading) {
+    e.dirty = true;
+    return e.reading;
+  }
+  e.reading = (async () => {
+    do {
+      e.dirty = false;
+      const dir = videoDirs().get(slug);
+      if (!dir) {
+        statuses.delete(slug);
+        return;
+      }
+      const r = await limitConcurrency(() => run([PYTHON, join(TOOLS_DIR, "omnivideo.py"), "status", dir, "--json"]));
+      if (r.code === 0) {
+        e.data = JSON.parse(r.stdout);
+        e.error = undefined;
+      } else e.error = r.stderr.trim() || `status saiu com ${r.code}`;
+    } while (e.dirty);
+  })().finally(() => {
+    e.reading = undefined;
+  });
+  return e.reading;
+}
+
+async function status(slug: string) {
+  const e = statuses.get(slug);
+  if (!e?.data && !e?.error) await refreshStatus(slug);
+  return statuses.get(slug);
+}
+
+/* --- reference swap --------------------------------------------------------
+   Requested from the UI (api/services/create.ts). Applied when motion.md was rewritten
+   after the request and the scenes.json `references` are already the new ones. */
+function referenceSwap(dir: string, scenes: any) {
+  const t = readJson<{ from: string[]; to: string | null; note: string | null; requested_at: string }>(
+    join(dir, "motion", "reference-swap.json"),
+  );
+  if (!t) return null;
+  let rewritten = false;
+  try {
+    rewritten = statSync(join(dir, "motion.md")).mtimeMs > Date.parse(t.requested_at);
+  } catch {
+    /* no motion.md */
+  }
+  const refs: string[] = scenes?.references ?? [];
+  const isNew = t.to ? refs.includes(t.to) : refs.join() !== t.from.join();
+  return { ...t, applied: rewritten && isNew };
+}
+
+/* --- summary and detail --------------------------------------------------------- */
+function titleOf(dir: string, scenes: any): string | null {
+  if (scenes?.title) return scenes.title;
+  const fromCarousel = readJson<{ title?: string }>(join(dir, "carousel", "carousel.json"))?.title;
+  if (fromCarousel && !existsSync(join(dir, "script.md"))) return fromCarousel;
+  const script = readText(join(dir, "script.md"));
+  const h1 =
+    script?.match(/^#\s+(?:Roteiro\s*·\s*)?(.+)$/m) ??
+    readText(join(dir, "source", "request.md"))?.match(/^#\s+(.+)$/m);
+  return h1?.[1]?.trim() ?? null;
+}
+
+/* the still of the first scene, for the list */
+function coverOf(dir: string, scenes: any) {
+  const id = scenes?.scenes?.[0]?.id;
+  if (!id) return null;
+  const path = `motion/stills/${id}.png`;
+  try {
+    return { path, size: 0, mtime: Math.round(statSync(join(dir, path)).mtimeMs) };
+  } catch {
+    return null;
+  }
+}
+
+function chosenThumbnail(dir: string) {
+  if (!readJson<any>(join(dir, "thumbnail", "thumbnail.json"))?.selected) return null;
+  const path = "thumbnail/thumbnail.png";
+  try {
+    return { path, size: 0, mtime: Math.round(statSync(join(dir, path)).mtimeMs) };
+  } catch {
+    return null;
+  }
+}
+
+function lastModified(dir: string): number {
+  let t = 0;
+  for (const f of [
+    "scenes.json",
+    "script.md",
+    "motion.md",
+    "brief.md",
+    "source/request.md",
+    "captions.srt",
+    "premiere.json",
+    "export/assembly.json",
+    "publication.json",
+    "script-approval.json",
+    "motion/approval.json",
+    "motion/reference-swap.json",
+    /* Instagram omnichat: the rule and the record, which the agent writes when it replies to someone */
+    "omnichat.json",
+    "omnichat-record.json",
+    /* the content's carousel */
+    "content.json",
+    "carousel/carousel.json",
+    "carousel/build.json",
+    "carousel/publication.json",
+    "carousel/export/export.json",
+    "carousel/omnichat.json",
+    "carousel/omnichat-record.json",
+  ]) {
+    try {
+      t = Math.max(t, statSync(join(dir, f)).mtimeMs);
+    } catch {
+      /* does not exist yet */
+    }
+  }
+  return t;
+}
+
+/* when the video was created: the dir's creation (on macOS, the birth time) */
+function createdAt(dir: string): number {
+  try {
+    const st = statSync(dir);
+    return Math.round(st.birthtimeMs || st.mtimeMs);
+  } catch {
+    return 0;
+  }
+}
+
+export async function videoSummary(slug: string, dir: string, q: Queue) {
+  const st = await status(slug);
+  const scenes = readJson(join(dir, "scenes.json"));
+  const mine = (s: Ticket) => s.dir === dir;
+  const carousel = carouselSummary(dir);
+  return {
+    slug,
+    dir,
+    /* what this content delivers: video, carousel or both (api/services/carousel.ts) */
+    deliverables: deliverables(dir),
+    narration: narration(dir),
+    carousel,
+    title: titleOf(dir, scenes) ?? slug,
+    format: scenes?.format ?? null,
+    status: st?.data ?? null,
+    statusError: st?.error ?? null,
+    /* approval of the motion script scenes; an expired deadline is applied on this read */
+    scenes_approval: scenesApprovalOf(dir),
+    /* approval of the content script, the same way */
+    script_approval: scriptApprovalOf(dir),
+    reference_swap: referenceSwap(dir, scenes),
+    /* without video, the cover is the carousel's first slide */
+    cover: coverOf(dir, scenes) ?? (carousel && "cover" in carousel ? carousel.cover : null),
+    /* the selected thumbnail: the cover the publication sends (the schedule shows it) */
+    thumbnail: chosenThumbnail(dir),
+    created: createdAt(dir),
+    updated: lastModified(dir),
+    publication: readJson(join(dir, "publication.json")),
+    /* when it was archived (archived.json, api/services/archive.ts); null in the work list */
+    archived: readJson<{ at?: string }>(join(dir, "archived.json"))?.at ?? null,
+    tasks: {
+      running: q.running.filter(mine),
+      waiting: q.waiting.filter(mine).map(s => ({ ...s, position: q.waiting.indexOf(s) + 1 })),
+    },
+  };
+}
+
+/* Times as the build will use them: beat resolved by line or word, line
+   positioned (or estimated, if the voice does not exist yet) */
+function resolveTimings(dir: string) {
+  const v = loadVideo(dir);
+  return {
+    provisional: v.provisional,
+    total_duration: v.total_duration,
+    scenes: v.scenes.map((c: any) => ({
+      id: c.id,
+      start: c.start,
+      duration: c.duration,
+      beats: (c.beats ?? []).map((b: any) => {
+        try {
+          return { element: b.element, t: beatTime(c, b) };
+        } catch (e: any) {
+          return { element: b.element, error: e.message };
+        }
+      }),
+      lines: (c.lines ?? []).map((l: any) => ({ id: l.id, start: l.start, end: l.end })),
+    })),
+  };
+}
+
+/* thumbnail/request.json: the random ones and the manual version; the old
+   shape ({ at, request }, before that { em, pedido }) was a single request, the one for the three */
+function thumbnailRequestOf(p: any) {
+  if (!p) return null;
+  if ("at" in p || "em" in p) return { random: { at: p.at ?? p.em }, manual: null, changes: {} };
+  return { random: p.random ?? null, manual: p.manual ?? null, changes: p.changes ?? {} };
+}
+
+/* export/assembly.json: an old file may still carry the lineId → clips map in `lines` */
+function assemblyOf(a: any) {
+  if (a && a.lines && typeof a.lines === "object") {
+    a.line_clips ??= a.lines;
+    a.lines = Object.keys(a.lines).length;
+  }
+  return a;
+}
+
+/* media the UI shows, with mtime so the URL changes when the file changes */
+const MEDIA = /\.(png|jpe?g|webp|mp4|mov|webm|wav|mp3|m4a)$/i;
+function mediaFiles(dir: string) {
+  const list: FileEntry[] = [];
+  const walk = (sub: string, deep: boolean) => {
+    let names: string[];
+    try {
+      names = readdirSync(join(dir, sub));
+    } catch {
+      return;
+    }
+    for (const name of names.sort()) {
+      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;
+      }
+      if (MEDIA.test(name)) list.push({ path: rel, size: st.size, mtime: Math.round(st.mtimeMs) });
+    }
+  };
+  for (const sub of ["motion", "voice", "export", "check", "sound", "thumbnail"]) walk(sub, sub === "motion");
+  return list.filter(a => !a.path.startsWith("motion/src/"));
+}
+
+/* Previous versions the tools kept (tools/history.*), in
+   history/<stage>/[<key>/]<stamp>/. The stamp is the time of the original
+   result: it is how the UI finds the queue run that produced it. */
+const STAMP_RE = /^(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z$/;
+function historyOf(dir: string) {
+  const versions: {
+    stage: string;
+    key: string | null;
+    at: string;
+    files: FileEntry[];
+    data: Record<string, unknown>;
+  }[] = [];
+  const names = (d: string) => {
+    try {
+      return readdirSync(d)
+        .filter(n => !n.startsWith("."))
+        .sort();
+    } catch {
+      return [];
+    }
+  };
+  const read = (stage: string, key: string | null, d: string) => {
+    for (const name of names(d)) {
+      const m = STAMP_RE.exec(name);
+      if (!m) {
+        if (key === null) read(stage, name, join(d, name));
+        continue;
+      }
+      const vdir = join(d, name);
+      const files: FileEntry[] = names(vdir).flatMap(n => {
+        try {
+          const st = statSync(join(vdir, n));
+          return [{ path: relative(dir, join(vdir, n)), size: st.size, mtime: Math.round(st.mtimeMs) }];
+        } catch {
+          return [];
+        }
+      });
+      const data = Object.fromEntries(
+        files
+          .filter(a => a.path.endsWith(".json") && a.size < 65_536)
+          .map(a => [basename(a.path), readJson(join(dir, a.path))]),
+      );
+      versions.push({ stage, key, at: `${m[1]}T${m[2]}:${m[3]}:${m[4]}.${m[5]}Z`, files, data });
+    }
+  };
+  /* history/preview/ is from the preview stage that no longer exists: nothing shows it */
+  for (const stage of names(join(dir, "history")).filter(n => n !== "preview"))
+    read(stage, null, join(dir, "history", stage));
+  return versions.sort((a, b) => b.at.localeCompare(a.at));
+}
+
+export async function videoDetail(slug: string, q: Queue) {
+  const dir = videoDirs().get(slug);
+  if (!dir) return null;
+  const base = await videoSummary(slug, dir, q);
+  const scenes = readJson(join(dir, "scenes.json"));
+  let resolved = null;
+  let resolvedError = null;
+  if (scenes) {
+    try {
+      resolved = resolveTimings(dir);
+    } catch (e: any) {
+      resolvedError = e.message;
+    }
+  }
+  const renders = Object.fromEntries(
+    (scenes?.scenes ?? []).map((c: any) => [c.id, readJson(join(dir, "motion", `${c.id}.render.json`))]),
+  );
+  return {
+    ...base,
+    root: relative(ROOT, dir).startsWith("..") ? dir : relative(ROOT, dir),
+    scenes,
+    resolved,
+    resolvedError,
+    texts: {
+      script: readText(join(dir, "script.md")),
+      motion: readText(join(dir, "motion.md")),
+      brief: readText(join(dir, "brief.md")),
+      captions: readText(join(dir, "captions.srt")),
+    },
+    files: mediaFiles(dir),
+    history: historyOf(dir),
+    /* every queue run of this video, including those already out of the recent list */
+    runs: listTickets()
+      .filter(s => s.dir === dir)
+      .sort((a, b) => b.arrived_at.localeCompare(a.arrived_at)),
+    premiere: readJson(join(dir, "premiere.json")),
+    assembly: assemblyOf(readJson(join(dir, "export", "assembly.json"))),
+    /* thumbnail on request (tools/thumbnail.mjs): the versions and the request still pending */
+    thumbnail: readJson(join(dir, "thumbnail", "thumbnail.json")),
+    thumbnailRequest: thumbnailRequestOf(readJson(join(dir, "thumbnail", "request.json"))),
+    sound: readJson(join(dir, "sound", "plan.json")),
+    renders,
+    carousel: carouselDetail(dir),
+  };
+}
+
+export async function listVideos(q: Queue) {
+  const all = await Promise.all([...videoDirs()].map(([slug, dir]) => videoSummary(slug, dir, q)));
+  /* newest first, by creation; the slug (which starts with the date) breaks ties */
+  return all.sort((a, b) => b.created - a.created || b.slug.localeCompare(a.slug));
+}

package/studio/api/services/voice-pause.ts

@@ -0,0 +1,98 @@
+/* Changing a voice from the UI pauses what comes after it. Whoever changes a voice (generates
+   another line, picks a version, edits the text, changes the video's model) wants the
+   video with the new voice: render, sound, captions and assembly running or
+   waiting for this video are no longer useful. So:
+
+   - they are interrupted (the whole tree: the render's Chrome, ffmpeg);
+   - the video's Claude session stops, if running, so it doesn't go on by itself;
+   - voice-pause.json in the video dir holds everything: job_queue.py and job-queue.mjs refuse
+     those tools, and the status shows the voice "being chosen".
+
+   The pause accumulates while the user changes more voices and only lifts through "Seguir com
+   estas vozes" in the Voice stage (voices.ts, `proceedWithVoices`), which resumes Claude. The voices
+   the user requests keep generating: voice is not "after the voice". */
+
+import { writeFileSync, renameSync, existsSync } from "node:fs";
+import { join, basename } from "node:path";
+import { readJson } from "./root";
+import { getQueue } from "./queue";
+import { latestSessionFor, stopSession } from "./sessions";
+
+export const PAUSE_FILE = "voice-pause.json";
+/* the same set as tools/job_queue.py and tools/job-queue.mjs */
+const AFTER_VOICE = new Set([
+  "render",
+  "sound",
+  "captions",
+  "assembly",
+  "premiere-assemble",
+  "premiere-check",
+  "premiere-export",
+]);
+
+/* `removed`: lines the user took out of the narration during the pause; "Seguir" takes them to Claude */
+export type VoicePause = {
+  since: string;
+  lines: string[];
+  interrupted: string[];
+  claude_stopped: boolean;
+  removed?: string[];
+};
+
+export const readPause = (dir: string) => readJson<VoicePause>(join(dir, PAUSE_FILE));
+export const isPaused = (dir: string) => existsSync(join(dir, PAUSE_FILE));
+
+/* the process and all its children (render opens Chromes; assembly, ffmpeg) */
+function killTree(pid: number) {
+  const children = Bun.spawnSync(["pgrep", "-P", String(pid)])
+    .stdout.toString()
+    .split("\n")
+    .filter(Boolean)
+    .map(Number);
+  for (const c of children) killTree(c);
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    /* already gone */
+  }
+}
+
+/* stops what comes after this video's voice (and the Claude session), without writing the pause */
+export function interruptAfterVoice(dir: string) {
+  const q = getQueue();
+  const interrupted: string[] = [];
+  for (const s of [...q.running, ...q.waiting]) {
+    if (s.dir !== dir || !AFTER_VOICE.has(s.tool)) continue;
+    killTree(s.pid);
+    interrupted.push(s.tool);
+  }
+  const session = latestSessionFor("video", basename(dir));
+  const claude = session?.state === "running" ? stopSession(session.id).ok : false;
+  return { interrupted, claude };
+}
+
+/* `lines`: what changed (line ids, or "video-voice" when the model changes) */
+export function pauseAfterVoice(dir: string, lines: string[], removed: string[] = []): VoicePause {
+  const { interrupted, claude } = interruptAfterVoice(dir);
+
+  const before = readPause(dir);
+  const out = [...new Set([...(before?.removed ?? []), ...removed])];
+  const pause: VoicePause = {
+    since: before?.since ?? new Date().toISOString(),
+    lines: [...new Set([...(before?.lines ?? []), ...lines])].filter(l => !out.includes(l)),
+    interrupted: [...new Set([...(before?.interrupted ?? []), ...interrupted])],
+    claude_stopped: !!before?.claude_stopped || claude,
+    ...(out.length ? { removed: out } : {}),
+  };
+  const file = join(dir, PAUSE_FILE);
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(pause, null, 2) + "\n");
+  renameSync(tmp, file);
+  return pause;
+}
+
+/* what the response tells the user about the pause */
+export function pauseNotice(p: VoicePause) {
+  const stopped = [...p.interrupted, ...(p.claude_stopped ? ["o Claude"] : [])];
+  return `${stopped.length ? `parei ${stopped.join(", ")}; ` : ""}o vídeo espera você terminar as vozes ("Seguir com estas vozes" na etapa Voz)`;
+}