@crievo/omni 0.0.0-stage → 0.1.1

package/studio/api/services/onboarding.ts

@@ -0,0 +1,77 @@
+/* Getting started (/getting-started): the guide in docs/onboarding.md, one step per section
+   (`<!-- step: id -->`), with each step's state measured by `tools/setup.mjs
+   check --json`. The guide owns the text: the UI repeats none of it. */
+
+import { join, resolve, sep } from "node:path";
+import { CODE_ROOT, NODE, TOOLS_DIR, run, readText } from "./root";
+
+export const DOCS_DIR = join(CODE_ROOT, "docs");
+const GUIDE = join(DOCS_DIR, "onboarding.md");
+
+type Check = { id: string; title: string; state: "ok" | "missing" | "warning"; detail: string };
+type CheckResult = {
+  ready: boolean;
+  steps: { id: string; state: Check["state"]; optional?: boolean; items: Check[] }[];
+};
+export type OnboardingStep = {
+  id: string;
+  title: string;
+  markdown: string;
+  state: Check["state"] | null;
+  optional: boolean;
+  items: Check[];
+};
+
+/* the check runs programs (bun, ffmpeg, python…): cache it briefly so the overview doesn't pay on every visit */
+let cached: { at: number; r: CheckResult } | null = null;
+async function runChecks(fresh: boolean): Promise<CheckResult | null> {
+  if (!fresh && cached && Date.now() - cached.at < 60_000) return cached.r;
+  const r = await run([NODE, join(TOOLS_DIR, "setup.mjs"), "check", "--json"]);
+  try {
+    cached = { at: Date.now(), r: JSON.parse(r.stdout) };
+    return cached.r;
+  } catch {
+    return null;
+  }
+}
+
+/* an image relative to the guide (onboarding/x.png) becomes the studio's /docs/… route; a link to another
+   repo file becomes the path in code (in the studio it has nowhere to go) */
+const withImages = (md: string) =>
+  md
+    .replace(/!\[([^\]]*)\]\((?!https?:|\/)([^)\s]+)\)/g, "![$1](/docs/$2)")
+    .replace(/(?<!!)\[([^\]]+)\]\((?!https?:|\/|#)(?:\.\.\/)?([^)\s]+)\)/g, (_, text: string, target: string) =>
+      text.includes("`") ? text : `${text} (\`${target}\`)`,
+    );
+
+export async function getOnboarding(fresh = false) {
+  const text = readText(GUIDE);
+  if (!text) return { error: "docs/onboarding.md não existe" };
+  const checks = await runChecks(fresh);
+  const [head, ...sections] = text.split(/<!--\s*step:\s*([\w-]+)\s*-->/);
+  /* split interleaves: id, body, id, body… */
+  const steps: OnboardingStep[] = [];
+  for (let i = 0; i < sections.length; i += 2) {
+    const id = sections[i];
+    const body = sections[i + 1].trim();
+    const m = body.match(/^##\s+(.+)\n/);
+    const c = checks?.steps.find(p => p.id === id);
+    steps.push({
+      id,
+      title: m ? m[1].trim() : id,
+      markdown: withImages(m ? body.slice(m[0].length) : body).trim(),
+      state: c?.state ?? null,
+      optional: !!c?.optional,
+      items: c?.items ?? [],
+    });
+  }
+  const intro = withImages(head.replace(/^#\s+.+\n/, "")).trim();
+  return { ready: checks?.ready ?? false, checked: !!checks, intro, steps };
+}
+
+/* /docs/<path>: the guide's images */
+export function docFile(rel: string): string | null {
+  if (!/\.(png|jpe?g|webp|gif)$/i.test(rel)) return null;
+  const abs = resolve(DOCS_DIR, rel);
+  return abs.startsWith(DOCS_DIR + sep) ? abs : null;
+}

package/studio/api/services/publish.ts

@@ -0,0 +1,287 @@
+/* Publishing from the UI: the export stage button. Writes the text to
+   publication.json and calls `publish.mjs --confirm`, the same the terminal
+   would call: it uploads, checks the limits and records the result. The accounts
+   (`status --json`) are cached for a few minutes: each read refreshes
+   tokens and asks the three platforms. */
+
+import { writeFileSync, renameSync, statSync } from "node:fs";
+import { join } from "node:path";
+import type { Subprocess } from "bun";
+import { NODE, ROOT, TOOLS_DIR, run, readJson } from "./root";
+
+type Result = { ok: true; output: string } | { ok: false; error: string };
+
+const PUBLISH = join(TOOLS_DIR, "publish.mjs");
+const PLATFORMS = ["youtube", "instagram", "tiktok"];
+const PRIVACIES = ["private", "unlisted", "public"];
+const TIKTOK_PRIVACIES = ["SELF_ONLY", "MUTUAL_FOLLOW_FRIENDS", "FOLLOWER_OF_CREATOR", "PUBLIC_TO_EVERYONE"];
+
+/* a login done from the terminal (`publish.mjs auth`) changes .env without going through here:
+   a .env newer than the cached read counts as a refresh */
+const ENV_FILE = join(ROOT, ".env");
+const envChanged = (since: number) => {
+  try {
+    return statSync(ENV_FILE).mtimeMs > since;
+  } catch {
+    return false;
+  }
+};
+
+let cachedAccounts: { at: number; data: unknown } | null = null;
+export async function getAccounts(refresh = false) {
+  if (!refresh && cachedAccounts && Date.now() - cachedAccounts.at < 5 * 60_000 && !envChanged(cachedAccounts.at))
+    return cachedAccounts.data;
+  const r = await run([NODE, PUBLISH, "status", "--json"]);
+  let data: unknown;
+  try {
+    data = JSON.parse(r.stdout);
+  } catch {
+    data = { error: (r.stderr || r.stdout).trim() || `publish.mjs saiu com ${r.code}` };
+  }
+  cachedAccounts = { at: Date.now(), data };
+  return data;
+}
+
+export const forgetAccounts = () => {
+  cachedAccounts = null;
+};
+
+/* Connecting an account from the UI: the same `publish.mjs auth` as the terminal. Instagram's
+   gets the token generated in the Meta dashboard, through the environment (it doesn't go
+   to argv, which shows in the process list).
+
+   YouTube's and TikTok's answer as soon as the link exists (the `url:` line
+   of publish.mjs) and keep waiting for the login to come back for up to 10 min: the UI
+   shows the link to copy and asks for the end with GET
+   /api/settings/publish/connect?platform=…. `mode`: "dia" opens in Dia,
+   "link" only generates the link, any other value opens in the default browser. */
+type Connection = {
+  state: "waiting" | "ok" | "error";
+  url: string | null;
+  output: string;
+  at: number;
+  proc: Subprocess;
+};
+const BROWSER_LOGIN_PLATFORMS = ["youtube", "tiktok"];
+const connections: Record<string, Connection | null> = {};
+
+export function connectionStatus(platform: unknown) {
+  const c = connections[BROWSER_LOGIN_PLATFORMS.includes(String(platform)) ? String(platform) : "youtube"];
+  return c ? { state: c.state, url: c.state === "waiting" ? c.url : null, output: c.output.trim(), at: c.at } : null;
+}
+
+async function connectInBrowser(platform: string, mode: unknown): Promise<Result & { url?: string }> {
+  const flags = mode === "link" ? ["--no-open"] : mode === "dia" ? ["--browser", "Dia"] : [];
+  /* a new link replaces the one still waiting */
+  if (connections[platform]?.state === "waiting") connections[platform]!.proc.kill();
+  const p = Bun.spawn([NODE, PUBLISH, "auth", platform, ...flags], { cwd: ROOT, stdout: "pipe", stderr: "pipe" });
+  const c: Connection = { state: "waiting", url: null, output: "", at: Date.now(), proc: p };
+  connections[platform] = c;
+  const account = platform === "youtube" ? "a conta do canal" : "a conta do TikTok";
+  let found: (u: string | null) => void = () => {};
+  const link = new Promise<string | null>(r => {
+    found = r;
+  });
+  (async () => {
+    const dec = new TextDecoder();
+    for await (const chunk of p.stdout) {
+      c.output += dec.decode(chunk);
+      const m = /^url: (\S+)/m.exec(c.output);
+      if (m && !c.url) {
+        c.url = m[1];
+        found(m[1]);
+      }
+    }
+  })();
+  const stderr = new Response(p.stderr).text();
+  p.exited.then(async code => {
+    const e = (await stderr).trim();
+    if (e) c.output += `\n${e}`;
+    if (connections[platform] === c) c.state = code === 0 ? "ok" : "error";
+    cachedAccounts = null;
+    found(null);
+  });
+  const url = await Promise.race([link, Bun.sleep(8000).then(() => null)]);
+  if (!url) {
+    p.kill();
+    return { ok: false, error: c.output.replace(/^url: .*$/m, "").trim() || "o publish.mjs não gerou o link do login" };
+  }
+  const notOpened = /não abriu/.test(c.output);
+  const output =
+    mode === "link"
+      ? `link gerado: abra num navegador desta máquina e escolha ${account}`
+      : notOpened
+        ? `${mode === "dia" ? "o Dia" : "o navegador"} não abriu: copie o link abaixo`
+        : `login aberto ${mode === "dia" ? "no Dia" : "no navegador"}: escolha ${account}`;
+  return { ok: true, output, url };
+}
+
+let connecting: string | null = null;
+export async function connectPlatform(
+  platform: unknown,
+  token: unknown,
+  mode?: unknown,
+): Promise<Result & { url?: string }> {
+  if (BROWSER_LOGIN_PLATFORMS.includes(String(platform))) return connectInBrowser(String(platform), mode);
+  if (platform !== "instagram") return { ok: false, error: `plataforma desconhecida: ${platform}` };
+  if (connecting) return { ok: false, error: `já tem uma conexão em andamento (${connecting})` };
+  let env: Record<string, string> = {};
+  if (platform === "instagram") {
+    const t = typeof token === "string" ? token.trim() : "";
+    if (!/^[\w.-]{20,}$/.test(t))
+      return { ok: false, error: "cole o token gerado em Instagram → API setup → Generate access tokens" };
+    env = { OMNIVIDEO_IG_TOKEN: t };
+  }
+  connecting = platform;
+  try {
+    const r = await run([NODE, PUBLISH, "auth", platform], env);
+    cachedAccounts = null;
+    const output = [r.stdout, r.stderr]
+      .map(s => s.trim())
+      .filter(Boolean)
+      .join("\n");
+    return r.code === 0
+      ? { ok: true, output: output.split("\n").pop() ?? "conectado" }
+      : { ok: false, error: output || `publish.mjs saiu com ${r.code}` };
+  } finally {
+    connecting = null;
+  }
+}
+
+/* one video publishing at a time: two clicks don't upload twice */
+const publishing = new Set<string>();
+
+/* Title, description, caption and tags from the script (`publish.mjs text`):
+   Claude writes them, and without it they come from the script itself. Without `redo`, only what
+   is empty in publication.json. */
+const writing = new Set<string>();
+
+export async function generatePublishText(dir: string, redo: boolean): Promise<Result & { text?: unknown }> {
+  if (writing.has(dir)) return { ok: false, error: "o texto deste vídeo já está sendo escrito" };
+  writing.add(dir);
+  try {
+    const r = await run([NODE, PUBLISH, "text", dir, "--json", ...(redo ? ["--redo"] : [])]);
+    if (r.code !== 0) return { ok: false, error: (r.stderr || r.stdout).trim() || `publish.mjs saiu com ${r.code}` };
+    const t = JSON.parse(r.stdout.trim().split("\n").pop()!);
+    const output =
+      t.warning ??
+      (t.by === "claude"
+        ? "texto escrito pelo Claude a partir do roteiro"
+        : t.by
+          ? "texto tirado do roteiro"
+          : "o texto já estava escrito");
+    return { ok: true, output, text: t };
+  } catch (e: any) {
+    return { ok: false, error: `não deu para ler o texto: ${e.message}` };
+  } finally {
+    writing.delete(dir);
+  }
+}
+
+/* the UI request (where, privacy, again) as publish.mjs flags; writes the text
+   to publication.json, which stays even if publishing fails (the caption counts for Instagram and TikTok) */
+function publishFlags(dir: string, body: any): { flags: string[] } | { error: string } {
+  const platforms = PLATFORMS.filter(p => body?.[p] === true);
+  if (!platforms.length) return { error: "escolha ao menos uma plataforma" };
+  const privacy = String(body?.privacy ?? "public");
+  if (!PRIVACIES.includes(privacy)) return { error: `privacidade desconhecida: ${privacy}` };
+  const tiktokPrivacy = String(body?.tiktok_privacy ?? "PUBLIC_TO_EVERYONE");
+  if (!TIKTOK_PRIVACIES.includes(tiktokPrivacy))
+    return { error: `privacidade do TikTok desconhecida: ${tiktokPrivacy}` };
+
+  const file = join(dir, "publication.json");
+  const pub = readJson<Record<string, unknown>>(file) ?? {};
+  for (const k of ["title", "description", "caption"]) {
+    if (typeof body?.[k] === "string") pub[k] = body[k].trim();
+  }
+  if (typeof body?.caption === "string") delete pub.caption_instagram;
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(pub, null, 2) + "\n");
+  renameSync(tmp, file);
+  return {
+    flags: [
+      ...platforms.map(p => `--${p}`),
+      "--privacy",
+      privacy,
+      "--tiktok-privacy",
+      tiktokPrivacy,
+      "--confirm",
+      ...(body?.republish === true ? ["--again"] : []),
+    ],
+  };
+}
+
+const joinOutput = (r: { stdout: string; stderr: string }) =>
+  [r.stdout, r.stderr]
+    .map(s => s.trim())
+    .filter(Boolean)
+    .join("\n");
+
+export async function publishVideo(dir: string, body: any): Promise<Result> {
+  if (publishing.has(dir)) return { ok: false, error: "este vídeo já está sendo publicado" };
+  const p = publishFlags(dir, body);
+  if ("error" in p) return { ok: false, error: p.error };
+  publishing.add(dir);
+  try {
+    const r = await run([NODE, PUBLISH, dir, ...p.flags], { OMNIVIDEO_ORIGIN: "studio" });
+    cachedAccounts = null;
+    const output = joinOutput(r);
+    return r.code === 0 ? { ok: true, output } : { ok: false, error: output || `publish.mjs saiu com ${r.code}` };
+  } finally {
+    publishing.delete(dir);
+  }
+}
+
+/* Scheduling from the UI: the same request as the Publish button, for the day and time in `when`
+   (ISO, converted from local time by the UI). The scheduler agent uploads on time
+   (`publish.mjs scheduler install`), with the studio open or not. */
+export async function schedulePublish(dir: string, body: any): Promise<Result> {
+  if (publishing.has(dir)) return { ok: false, error: "este vídeo está sendo publicado agora" };
+  const when = String(body?.when ?? "");
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(when) || Number.isNaN(Date.parse(when)))
+    return { ok: false, error: "escolha o dia e a hora" };
+  const p = publishFlags(dir, body);
+  if ("error" in p) return { ok: false, error: p.error };
+  const r = await run([NODE, PUBLISH, "schedule", dir, "--when", when, ...p.flags], { OMNIVIDEO_ORIGIN: "studio" });
+  const output = joinOutput(r);
+  return r.code === 0 ? { ok: true, output } : { ok: false, error: output || `publish.mjs saiu com ${r.code}` };
+}
+
+/* Rescheduling from the schedule (dragging the post): the same schedule, another time. `when`
+   in ISO; publish.mjs refuses a time already past */
+export async function reschedulePublish(dir: string, body: any): Promise<Result> {
+  if (publishing.has(dir)) return { ok: false, error: "este vídeo está sendo publicado agora" };
+  const when = String(body?.when ?? "");
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(when) || Number.isNaN(Date.parse(when)))
+    return { ok: false, error: "escolha o dia e a hora" };
+  const r = await run([NODE, PUBLISH, "schedule", dir, "--reschedule", "--when", when, "--confirm"], {
+    OMNIVIDEO_ORIGIN: "studio",
+  });
+  const output = joinOutput(r);
+  return r.code === 0 ? { ok: true, output } : { ok: false, error: output || `publish.mjs saiu com ${r.code}` };
+}
+
+export async function cancelScheduledPublish(dir: string): Promise<Result> {
+  const r = await run([NODE, PUBLISH, "schedule", dir, "--cancel"]);
+  const output = joinOutput(r);
+  return r.code === 0 ? { ok: true, output } : { ok: false, error: output || `publish.mjs saiu com ${r.code}` };
+}
+
+/* `scheduler --json`: the agent and everything scheduled, across all videos */
+export async function getSchedule() {
+  const r = await run([NODE, PUBLISH, "scheduler", "--json"]);
+  try {
+    return JSON.parse(r.stdout);
+  } catch {
+    return { error: joinOutput(r) || `publish.mjs saiu com ${r.code}` };
+  }
+}
+
+/* enables and disables the launchd agent: installs with the studio's node */
+export async function setScheduleAgent(enable: unknown): Promise<Result> {
+  if (typeof enable !== "boolean") return { ok: false, error: "enable: true ou false" };
+  const r = await run([NODE, PUBLISH, "scheduler", enable ? "install" : "uninstall"]);
+  cachedAccounts = null;
+  const output = joinOutput(r);
+  return r.code === 0 ? { ok: true, output } : { ok: false, error: output || `publish.mjs saiu com ${r.code}` };
+}

package/studio/api/services/queue.ts

@@ -0,0 +1,150 @@
+/* Reads the machine queue. The writer is tools/job_queue.py (and its guardian
+   for the Node tools); the studio only reads .queue/ and applies the same
+   liveness rule: an active ticket whose process is dead, or with no heartbeat for
+   more than 15 s, is interrupted. */
+
+import { readdirSync, statSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { QUEUE_DIR, ROOT, readJson } from "./root";
+
+const STALE_MS = 15_000;
+const ACTIVE_STATES = new Set(["waiting", "running"]);
+
+export type Ticket = {
+  id: string;
+  tool: string;
+  video: string | null;
+  dir: string | null;
+  command: string;
+  pid: number;
+  guardian: number | null;
+  origin: string;
+  session: string | null;
+  state: string;
+  effective: string;
+  order: number;
+  arrived_at: string;
+  started_at: string | null;
+  ended_at: string | null;
+  exit_code: number | null;
+  log: string;
+};
+
+export type Queue = { running: Ticket[]; waiting: Ticket[]; recent: Ticket[] };
+
+/* a zombie counts as dead: kill(pid, 0) answers for it, and a studio child that
+   exits after a `bun --watch` reload stays a zombie forever (the new image
+   doesn't know it exists and never reaps its exit) */
+export function isAlive(pid: number) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+  } catch (e: any) {
+    if (e.code !== "EPERM") return false;
+  }
+  const ps = Bun.spawnSync(["ps", "-o", "stat=", "-p", String(pid)]);
+  return !ps.stdout.toString().trim().startsWith("Z");
+}
+
+export function listTickets(): Ticket[] {
+  if (!existsSync(QUEUE_DIR)) mkdirSync(QUEUE_DIR, { recursive: true });
+  const now = Date.now();
+  const all: Ticket[] = [];
+  for (const name of readdirSync(QUEUE_DIR)) {
+    if (!name.endsWith(".json")) continue;
+    const file = join(QUEUE_DIR, name);
+    const ticket = readJson<Ticket>(file);
+    if (!ticket) continue;
+    let mtime = 0;
+    try {
+      mtime = statSync(file).mtimeMs;
+    } catch {
+      continue;
+    }
+    ticket.effective =
+      ACTIVE_STATES.has(ticket.state) && (!isAlive(ticket.pid) || now - mtime > STALE_MS)
+        ? "interrupted"
+        : ticket.state;
+    all.push(ticket);
+  }
+  return all;
+}
+
+const byOrder = (a: Ticket, b: Ticket) => a.order - b.order || a.pid - b.pid;
+
+export function getQueue(recent = 30): Queue {
+  const all = listTickets();
+  return {
+    running: all.filter(s => s.effective === "running").sort(byOrder),
+    waiting: all.filter(s => s.effective === "waiting").sort(byOrder),
+    recent: all
+      .filter(s => !ACTIVE_STATES.has(s.effective))
+      .sort((a, b) => (b.ended_at ?? b.arrived_at).localeCompare(a.ended_at ?? a.arrived_at))
+      .slice(0, recent),
+  };
+}
+
+export function getTicket(id: string): Ticket | null {
+  if (!/^[\w.-]+$/.test(id)) return null;
+  return listTickets().find(s => s.id === id) ?? null;
+}
+
+/* The log grows while the task runs. Sends what already exists and then only
+   what arrives, decoding as a stream (an accented character may be split
+   between two reads); ends when the task ends and the file stops. */
+export function streamTicketLog(id: string, req: Request): Response {
+  const s = getTicket(id);
+  if (!s) return new Response("tarefa não encontrada", { status: 404 });
+  const file = join(ROOT, s.log);
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  let pos = 0;
+  let busy = false;
+  let closed = false;
+  let timer: ReturnType<typeof setInterval>;
+  const stop = () => {
+    closed = true;
+    clearInterval(timer);
+  };
+  const body = new ReadableStream({
+    start(ctrl) {
+      const send = (event: string, data: unknown) =>
+        ctrl.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`));
+      const check = async () => {
+        if (busy || closed) return;
+        busy = true;
+        try {
+          /* state before size: the task writes the log before closing the
+             ticket, so if it has already finished here, everything it said is
+             in the file and goes out before the end */
+          const current = getTicket(id);
+          const f = Bun.file(file);
+          const size = (await f.exists()) ? f.size : 0;
+          if (size > pos) {
+            const bytes = new Uint8Array(await f.slice(pos, size).arrayBuffer());
+            pos = size;
+            const text = decoder.decode(bytes, { stream: true });
+            if (text) send("log", text);
+          }
+          if (!current || !ACTIVE_STATES.has(current.effective)) {
+            const rest = decoder.decode();
+            if (rest) send("log", rest);
+            send("end", { state: current?.effective ?? "gone", exit_code: current?.exit_code ?? null });
+            stop();
+            ctrl.close();
+          }
+        } catch {
+          /* client left in the middle of a read */
+          stop();
+        } finally {
+          busy = false;
+        }
+      };
+      timer = setInterval(check, 400);
+      check();
+      req.signal.addEventListener("abort", stop);
+    },
+    cancel: stop,
+  });
+  return new Response(body, { headers: { "content-type": "text/event-stream", "cache-control": "no-cache" } });
+}