@crievo/omni 0.0.0-stage → 0.1.0

package/tools/premiere.mjs

@@ -0,0 +1,533 @@
+#!/usr/bin/env node
+/* ============================================================================
+   Premiere MCP client (adobe-premiere-pro-mcp) for omnivideo.
+
+     node tools/premiere.mjs status
+     node tools/premiere.mjs call <tool> ['{"arg": 1}']
+     node tools/premiere.mjs assemble videos/<slug> [--redo]
+     node tools/premiere.mjs check    videos/<slug>
+     node tools/premiere.mjs export   videos/<slug>
+
+   Talks to the same server Claude Code registers as `premiere-pro` (stdio),
+   so any tool in the catalog works in `call`. The ones not always advertised
+   go through invoke_tool automatically.
+
+   Requires Premiere open with a project and the MCP Bridge (CEP) panel active.
+   assemble, check and export wait for their turn in the machine queue
+   (tools/job-queue.mjs): the bridge runs one script at a time, and export locks Premiere.
+   ============================================================================ */
+
+import { spawn, execFileSync } from "node:child_process";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { prepareSound } from "./sound.mjs";
+import { turn, running } from "./job-queue.mjs";
+import { keepPrevious } from "./history.mjs";
+import { DATA_ROOT as ROOT } from "./lib/paths.mjs";
+
+const CFG = JSON.parse(readFileSync(join(ROOT, "omnivideo.config.json"), "utf8"));
+const P = CFG.premiere;
+const ADVERTISED = new Set([
+  "verify_premiere_connection",
+  "list_sequences",
+  "search_tools",
+  "get_tool_schema",
+  "invoke_tool",
+]);
+
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+function fail(msg) {
+  console.error(`erro: ${msg}`);
+  process.exit(1);
+}
+
+/* --- MCP client over stdio ----------------------------------------------- */
+class Premiere {
+  constructor() {
+    this.proc = spawn(P.node, [P.server], { env: { ...process.env, PREMIERE_TEMP_DIR: P.temp_dir } });
+    this.buf = "";
+    this.next = 1;
+    this.pending = new Map();
+    this.proc.stdout.on("data", d => {
+      this.buf += d;
+      let i;
+      // biome-ignore lint/suspicious/noAssignInExpressions: line splitter loop
+      while ((i = this.buf.indexOf("\n")) >= 0) {
+        const line = this.buf.slice(0, i).trim();
+        this.buf = this.buf.slice(i + 1);
+        if (!line) continue;
+        const msg = JSON.parse(line);
+        const waiter = this.pending.get(msg.id);
+        if (!waiter) continue;
+        this.pending.delete(msg.id);
+        msg.error ? waiter.reject(new Error(msg.error.message)) : waiter.resolve(msg.result);
+      }
+    });
+    this.proc.stderr.on("data", () => {});
+  }
+
+  request(method, params, timeoutMs = 180_000) {
+    const id = this.next++;
+    this.proc.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method}: sem resposta em ${timeoutMs / 1000}s`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: v => {
+          clearTimeout(timer);
+          resolve(v);
+        },
+        reject: e => {
+          clearTimeout(timer);
+          reject(e);
+        },
+      });
+    });
+  }
+
+  async start() {
+    await this.request("initialize", {
+      protocolVersion: "2025-06-18",
+      capabilities: {},
+      clientInfo: { name: "omnivideo", version: "1" },
+    });
+    this.proc.stdin.write(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }) + "\n");
+    return this;
+  }
+
+  async tool(name, args = {}, timeoutMs) {
+    const params = ADVERTISED.has(name)
+      ? { name, arguments: args }
+      : { name: "invoke_tool", arguments: { name, arguments: args } };
+    const result = await this.request("tools/call", params, timeoutMs);
+    const text = (result.content ?? []).map(c => c.text ?? "").join("");
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      parsed = { success: false, raw: text };
+    }
+    /* the expanded catalog's tools return { success, tool, data: {...} } */
+    if (parsed.data && typeof parsed.data === "object" && !Array.isArray(parsed.data))
+      parsed = { ...parsed, ...parsed.data };
+    if (result.isError) parsed.success = false;
+    return parsed;
+  }
+
+  /* fails loudly: each assembly step depends on the previous one */
+  async must(name, args, timeoutMs) {
+    const r = await this.tool(name, args, timeoutMs);
+    if (r.success === false) throw new Error(`${name}: ${r.error ?? r.raw ?? JSON.stringify(r)}`);
+    return r;
+  }
+
+  close() {
+    this.proc.kill();
+  }
+}
+
+async function connect() {
+  const pp = await new Premiere().start();
+  const v = await pp.tool("verify_premiere_connection");
+  if (v.status !== "connected") {
+    pp.close();
+    fail(
+      `Premiere não conectado (${v.status ?? v.error}). Abra o Premiere com um projeto e o painel ` +
+        `Window → Extensions (Legacy) → MCP Bridge (CEP). Detalhe: ${v.nextStep ?? v.error ?? ""}`,
+    );
+  }
+  return { pp, info: v };
+}
+
+/* --- video ---------------------------------------------------------------- */
+function loadVideoDir(target) {
+  if (!target) fail("diga a pasta do vídeo: premiere.mjs <comando> videos/<slug>");
+  const dir = resolve(target);
+  const file = join(dir, "scenes.json");
+  if (!existsSync(file)) fail(`${file} não existe`);
+  return { dir, video: JSON.parse(readFileSync(file, "utf8")) };
+}
+
+function mediaDuration(path) {
+  try {
+    return +execFileSync("ffprobe", ["-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", path])
+      .toString()
+      .trim();
+  } catch {
+    return null;
+  }
+}
+
+function checkPrerequisites(dir, video) {
+  const fps = video.format.fps;
+  const problems = [];
+  for (const scene of video.scenes) {
+    const mp4 = join(dir, scene.mp4);
+    if (scene.duration == null) problems.push(`${scene.id}: sem duração — rode omnivideo.py timing`);
+    else if (!existsSync(mp4)) problems.push(`${scene.id}: ${scene.mp4} não existe`);
+    else {
+      const d = mediaDuration(mp4);
+      if (d == null || Math.abs(d - scene.duration) > 1.5 / fps) {
+        problems.push(
+          `${scene.id}: ${scene.mp4} tem ${d?.toFixed(3)}s, a cena pede ${scene.duration}s — renderize de novo`,
+        );
+      }
+      const reg = join(dir, "motion", `${scene.id}.render.json`);
+      const r = existsSync(reg) ? JSON.parse(readFileSync(reg, "utf8")) : null;
+      if (r?.video_time && Math.abs(r.start - scene.start) > 1e-3) {
+        problems.push(
+          `${scene.id}: renderizada começando em ${r.start}s, agora começa em ${scene.start}s; o fundo anda no tempo do vídeo e pularia no corte — renderize de novo`,
+        );
+      }
+    }
+    for (const line of scene.lines ?? []) {
+      if (!line.wav || !existsSync(join(dir, line.wav))) problems.push(`${line.id}: sem áudio`);
+      if (line.start == null) problems.push(`${line.id}: sem posição — rode omnivideo.py timing`);
+    }
+  }
+  if (!existsSync(join(dir, "captions.srt"))) problems.push("captions.srt não existe — rode omnivideo.py captions");
+  if (problems.length) fail("a montagem não pode começar:\n  " + problems.join("\n  "));
+}
+
+/* What can be checked without Premiere runs before waiting for the turn (an
+   incomplete video doesn't spend half an hour in the queue just to fail) and
+   again on the turn, with the files as they are then. */
+function prepareAssemble(target, redo) {
+  const { dir, video } = loadVideoDir(target);
+  const premiereFile = join(dir, "premiere.json");
+  const previous = existsSync(premiereFile) ? JSON.parse(readFileSync(premiereFile, "utf8")) : null;
+  if (previous?.sequenceId && !redo) {
+    fail(
+      `este vídeo já foi montado (sequência ${previous.sequenceName}). Use --redo para criar uma nova versão; a antiga fica no projeto.`,
+    );
+  }
+  checkPrerequisites(dir, video);
+  return { dir, video, premiereFile, previous };
+}
+
+function assembled(target) {
+  const { dir, video } = loadVideoDir(target);
+  const file = join(dir, "premiere.json");
+  const pj = existsSync(file) ? JSON.parse(readFileSync(file, "utf8")) : null;
+  if (!pj?.sequenceId) fail(`${target} ainda não foi montado (falta premiere.json): rode premiere.mjs assemble antes`);
+  return { dir, video, pj };
+}
+
+function prepareExport(target) {
+  const { dir, video, pj } = assembled(target);
+  const out = join(dir, "export", `${pj.sequenceName.replace(/\s+/g, "-")}.mp4`);
+  if (existsSync(out)) fail(`${out} já existe; apague ou renomeie antes de exportar de novo`);
+  if (!P.media_encoder_installed && !P.export_via_extendscript_approved) {
+    fail(
+      "nenhuma rota de exportação liberada. Instale o Adobe Media Encoder (Creative Cloud) e marque " +
+        "premiere.media_encoder_installed, ou aprove a exportação por ExtendScript marcando " +
+        "premiere.export_via_extendscript_approved em omnivideo.config.json.",
+    );
+  }
+  return { dir, video, pj, out };
+}
+
+/* status and call don't wait for the turn, but talk to the same bridge, which
+   runs one script at a time; while exporting, Premiere doesn't even answer. A
+   task that called from inside its own turn (OMNIVIDEO_TURN) doesn't count. */
+function premiereBusy() {
+  return running().find(
+    t =>
+      ["premiere-assemble", "premiere-check", "premiere-export"].includes(t.tool) &&
+      t.id !== process.env.OMNIVIDEO_TURN,
+  );
+}
+
+/* --- assemble ---------------------------------------------------------------- */
+async function assemble(target, redo) {
+  const { dir, video, premiereFile, previous } = prepareAssemble(target, redo);
+  /* beat effects: ready WAV, already at level, with the peak at the beat's
+     instant. Before connecting, so a missing effect stops the assembly early. */
+  const sound = prepareSound(dir, { preview: false, log: () => {} });
+  const soundTrack = CFG.sound?.premiere_track ?? 1;
+
+  const version = redo && previous ? ` v${(previous.version ?? 1) + 1}` : "";
+  const seqName = `${video.slug}${version}`;
+  const fps = video.format.fps;
+  const tol = 1 / fps + 0.01;
+  const { pp, info } = await connect();
+  console.log(`Premiere ${info.premiere?.version} · projeto ${info.project?.name}`);
+
+  try {
+    const bin = await pp.must("create_bin", { name: `omnivideo · ${seqName}` });
+    const items = {};
+    const importItem = async (key, rel) => {
+      const r = await pp.must("import_media", { filePath: join(dir, rel) });
+      await pp.must("move_item_to_bin", { projectItemId: r.id, targetBinId: bin.binId });
+      items[key] = r.id;
+    };
+    for (const scene of video.scenes) await importItem(scene.id, scene.mp4);
+    for (const scene of video.scenes) for (const line of scene.lines ?? []) await importItem(line.id, line.wav);
+    for (const it of sound.clips) await importItem(it.id, it.wav);
+    if (sound.bed) await importItem("bed", sound.bed.wav);
+    /* captions drawn in the motion itself (a style MCP doesn't apply): no
+       caption track, otherwise the text shows twice */
+    const captionsInPremiere = !video.captions_in_motion;
+    if (captionsInPremiere) await importItem("captions", "captions.srt");
+    console.log(`importados ${Object.keys(items).length} itens na pasta “omnivideo · ${seqName}”`);
+
+    /* the sequence is born from the motions, in order: it inherits resolution
+       and fps and already places the scenes back to back on V1, each at its scene.start */
+    const seq = await pp.must("create_sequence_from_clips", {
+      name: seqName,
+      projectItemIds: video.scenes.map(sc => items[sc.id]),
+    });
+    const sequenceId = seq.sequenceId;
+    console.log(`sequência “${seqName}” criada`);
+
+    for (const scene of video.scenes) {
+      for (const line of scene.lines ?? []) {
+        await pp.must("add_to_timeline", {
+          sequenceId,
+          projectItemId: items[line.id],
+          trackIndex: 0,
+          time: +(scene.start + line.start).toFixed(4),
+          insertMode: "overwrite",
+        });
+      }
+    }
+    for (const it of sound.clips) {
+      await pp.must("add_to_timeline", {
+        sequenceId,
+        projectItemId: items[it.id],
+        trackIndex: soundTrack,
+        time: +it.start.toFixed(4),
+        insertMode: "overwrite",
+      });
+    }
+    /* the bed goes on the track after the effects': it spans all of them */
+    if (sound.bed) {
+      await pp.must("add_to_timeline", {
+        sequenceId,
+        projectItemId: items.bed,
+        trackIndex: soundTrack + 1,
+        time: +sound.bed.start.toFixed(4),
+        insertMode: "overwrite",
+      });
+    }
+    if (captionsInPremiere)
+      await pp.must("create_caption_track", { sequenceId, projectItemId: items.captions, startTime: 0 });
+    for (const scene of video.scenes) {
+      await pp.must("add_marker", {
+        sequenceId,
+        time: scene.start,
+        name: `${scene.id} · ${scene.title ?? ""}`.trim(),
+        color: "blue",
+      });
+    }
+
+    /* check: does the timeline match scenes.json? */
+    const tracks = await pp.must("list_sequence_tracks", { sequenceId });
+    const v1 = tracks.videoTracks?.[0]?.clips ?? [];
+    const a1 = tracks.audioTracks?.[0]?.clips ?? [];
+    const warnings = [];
+    if (v1.length !== video.scenes.length) warnings.push(`V1 tem ${v1.length} clips, esperado ${video.scenes.length}`);
+    video.scenes.forEach((sc, i) => {
+      if (v1[i] && Math.abs(v1[i].startTime - sc.start) > tol)
+        warnings.push(`${sc.id} começa em ${v1[i].startTime}, esperado ${sc.start}`);
+    });
+    const lines = video.scenes.flatMap(sc => (sc.lines ?? []).map(l => ({ id: l.id, t: sc.start + l.start })));
+    if (a1.length !== lines.length) warnings.push(`A1 tem ${a1.length} clips, esperado ${lines.length}`);
+    lines.forEach((l, i) => {
+      if (a1[i] && Math.abs(a1[i].startTime - l.t) > tol)
+        warnings.push(`${l.id} começa em ${a1[i].startTime}, esperado ${l.t.toFixed(3)}`);
+    });
+    const aSound = tracks.audioTracks?.[soundTrack]?.clips ?? [];
+    if (aSound.length !== sound.clips.length)
+      warnings.push(`A${soundTrack + 1} tem ${aSound.length} clips, esperado ${sound.clips.length}`);
+    sound.clips.forEach((it, i) => {
+      if (aSound[i] && Math.abs(aSound[i].startTime - it.start) > tol)
+        warnings.push(`${it.id} começa em ${aSound[i].startTime}, esperado ${it.start.toFixed(3)}`);
+    });
+    const settings = await pp.tool("get_sequence_settings", { sequenceId });
+    const w = settings.settings?.frameWidth ?? settings.frameWidth ?? settings.width;
+    const h = settings.settings?.frameHeight ?? settings.frameHeight ?? settings.height;
+    if (w && h && (w !== video.format.w || h !== video.format.h))
+      warnings.push(`sequência ${w}×${h}, esperado ${video.format.w}×${video.format.h}`);
+
+    await pp.tool("set_active_sequence", { sequenceId });
+
+    const previousAssembly = keepPrevious(dir, "assembly", null, ["premiere.json"]);
+    writeFileSync(
+      premiereFile,
+      JSON.stringify(
+        {
+          sequenceId,
+          sequenceName: seqName,
+          binId: bin.binId,
+          version: (previous?.version ?? 0) + 1,
+          project: info.project?.path,
+          items,
+          sound: sound.clips.map(({ id, start, effects }) => ({ id, start, effects })),
+          assembled_at: new Date().toISOString(),
+          warnings,
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+    previousAssembly.close();
+
+    console.log(
+      `V1: ${v1.length} cenas · A1: ${a1.length} falas · A${soundTrack + 1}: ${aSound.length} efeitos · ` +
+        `${captionsInPremiere ? "trilha de legenda" : "legenda no motion"} e ${video.scenes.length} marcadores`,
+    );
+    sound.warnings.forEach(a => console.log(`efeito: ${a}`));
+    if (warnings.length) console.log("⚠ " + warnings.join("\n⚠ "));
+    else console.log("timeline confere com o scenes.json");
+  } finally {
+    pp.close();
+  }
+}
+
+/* --- check: one frame per scene, to read with the Read tool ---------- */
+async function check(target) {
+  const { dir, video, pj } = assembled(target);
+  const out = join(dir, "check");
+  mkdirSync(out, { recursive: true });
+  const previous = keepPrevious(
+    dir,
+    "check",
+    null,
+    video.scenes.map(sc => `check/${sc.id}.png`),
+  );
+  const { pp } = await connect();
+  try {
+    for (const scene of video.scenes) {
+      const line = (scene.lines ?? [])[0];
+      const t = scene.start + (line ? line.start + Math.min(1.2, line.dur / 2) : scene.duration / 2);
+      const png = join(out, `${scene.id}.png`);
+      await pp.must("export_frame", { sequenceId: pj.sequenceId, time: +t.toFixed(3), outputPath: png, format: "png" });
+      console.log(`${scene.id} em ${t.toFixed(2)}s → ${png}`);
+    }
+  } finally {
+    pp.close();
+    previous.close();
+  }
+}
+
+/* --- export ------------------------------------------------------------ */
+async function waitForFile(path, expectedDuration, limitMs) {
+  const started = Date.now();
+  let last = -1,
+    stable = 0;
+  while (Date.now() - started < limitMs) {
+    await sleep(3000);
+    if (!existsSync(path)) continue;
+    const size = statSync(path).size;
+    stable = size > 0 && size === last ? stable + 1 : 0;
+    last = size;
+    if (stable >= 2) {
+      const d = mediaDuration(path);
+      if (d && Math.abs(d - expectedDuration) < 0.5) return d;
+    }
+  }
+  return null;
+}
+
+async function exportSequence(target) {
+  const { dir, video, pj, out } = prepareExport(target);
+  mkdirSync(join(dir, "export"), { recursive: true });
+
+  const { pp } = await connect();
+  try {
+    if (P.media_encoder_installed) {
+      await pp.must("export_sequence", { sequenceId: pj.sequenceId, outputPath: out, presetPath: P.export_preset });
+      console.log("na fila do Media Encoder; aguardando o arquivo…");
+    } else if (P.export_via_extendscript_approved) {
+      const script = `
+        var seq = null;
+        for (var i = 0; i < app.project.sequences.numSequences; i++) {
+          if (app.project.sequences[i].sequenceID === ${JSON.stringify(pj.sequenceId)}) { seq = app.project.sequences[i]; break; }
+        }
+        if (!seq) return JSON.stringify({ success: false, error: "sequência não encontrada" });
+        var r = seq.exportAsMediaDirect(${JSON.stringify(out)}, ${JSON.stringify(P.export_preset)}, app.encoder.ENCODE_ENTIRE);
+        return JSON.stringify({ success: true, result: String(r) });`;
+      /* exportAsMediaDirect holds Premiere until it finishes; the answer may not
+         arrive before the panel's limit, so the file decides */
+      pp.tool("execute_extendscript", { script }, 30 * 60_000).then(
+        r => {
+          if (r.success === false) console.error(`Premiere: ${r.error ?? r.raw}`);
+        },
+        () => {},
+      );
+      console.log("exportando direto pelo Premiere; aguardando o arquivo…");
+    } else {
+      fail(
+        "nenhuma rota de exportação liberada. Instale o Adobe Media Encoder (Creative Cloud) e marque " +
+          "premiere.media_encoder_installed, ou aprove a exportação por ExtendScript marcando " +
+          "premiere.export_via_extendscript_approved em omnivideo.config.json.",
+      );
+    }
+    const d = await waitForFile(out, video.total_duration, 30 * 60_000);
+    if (!d) fail(`o arquivo não ficou pronto em 30 min: ${out}`);
+    pj.export = out;
+    pj.exported_at = new Date().toISOString();
+    writeFileSync(join(dir, "premiere.json"), JSON.stringify(pj, null, 2) + "\n");
+    console.log(`exportado: ${out} (${d.toFixed(2)}s)`);
+  } finally {
+    pp.close();
+  }
+}
+
+/* --- cli ------------------------------------------------------------------ */
+const [cmd, ...rest] = process.argv.slice(2);
+try {
+  if (cmd === "status") {
+    const busy = premiereBusy();
+    if (busy) {
+      console.log(
+        `Premiere ocupado: ${busy.tool} de ${busy.video} rodando na fila da máquina (pid ${busy.pid}). ` +
+          "A ponte responde quando terminar; assemble, check e export esperam a vez sozinhos.",
+      );
+    } else {
+      const { pp, info } = await connect();
+      console.log(JSON.stringify(info, null, 2));
+      pp.close();
+    }
+  } else if (cmd === "call") {
+    const [name, json] = rest;
+    if (!name) fail("uso: premiere.mjs call <ferramenta> ['{json}']");
+    const busy = premiereBusy();
+    if (busy && process.env.OMNIVIDEO_QUEUE !== "0") {
+      fail(
+        `Premiere ocupado: ${busy.tool} de ${busy.video} rodando na fila da máquina (pid ${busy.pid}). ` +
+          "Espere terminar ($PY tools/job_queue.py).",
+      );
+    }
+    const pp = await new Premiere().start();
+    console.log(JSON.stringify(await pp.tool(name, json ? JSON.parse(json) : {}), null, 2));
+    pp.close();
+  } else if (cmd === "assemble") {
+    prepareAssemble(rest[0], rest.includes("--redo"));
+    await turn("premiere-assemble", rest[0]);
+    await assemble(rest[0], rest.includes("--redo"));
+  } else if (cmd === "check") {
+    assembled(rest[0]);
+    await turn("premiere-check", rest[0]);
+    await check(rest[0]);
+  } else if (cmd === "export") {
+    prepareExport(rest[0]);
+    await turn("premiere-export", rest[0]);
+    await exportSequence(rest[0]);
+  } else {
+    console.log(
+      readFileSync(fileURLToPath(import.meta.url), "utf8")
+        .split("\n")
+        .slice(1, 19)
+        .join("\n"),
+    );
+    process.exit(2);
+  }
+} catch (e) {
+  fail(e.message);
+}
+process.exit(0);