@crievo/omni 0.0.0-stage → 0.1.1

package/tools/package.mjs

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+/* ============================================================================
+   The npm package of the `omni` CLI (docs/specs/phase-2-plugin-cli.md, step 4): `@crievo/omni`, built from
+   this repo into .release/npm/ and packed as a .tgz. It carries the code a user's machine runs (the CLI,
+   the pipeline tools, the templates and guides, the studio's API, runner and web) and nothing of the
+   skills, which come from the registry. The studio runs on the `bun` dependency, so a machine needs Node,
+   not Bun; Python's venv is made by `omni up`.
+
+     node tools/package.mjs [--version <x.y.z>]     builds and packs; prints the .tgz path
+     node tools/package.mjs publish [--version …]   builds, packs and publishes to npm with the account in
+                                                    NPM_CONFIG_USERCONFIG (e.g. ~/.npmrc-pedroflp)
+
+   Try it before publishing: npm install --prefix /tmp/omni-test <the .tgz>, then
+   /tmp/omni-test/node_modules/.bin/omni status
+   ============================================================================ */
+
+import { spawnSync } from "node:child_process";
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { PACKAGE } from "./lib/cli.mjs";
+import { CODE_ROOT } from "./lib/paths.mjs";
+
+const args = process.argv.slice(2);
+const flag = (/** @type {string} */ name) => {
+  const i = args.indexOf(`--${name}`);
+  return i < 0 ? undefined : (args[i + 1] ?? "");
+};
+const fail = (/** @type {string} */ m) => {
+  console.error(`erro: ${m}`);
+  process.exit(1);
+};
+
+const OUT = join(CODE_ROOT, ".release", "npm");
+const PKG = join(OUT, "package");
+
+/* what goes in, from the repo root; tests, one-off scripts and local state stay out */
+const INCLUDE = [
+  "bin/omni.mjs",
+  "tools",
+  "templates",
+  "reference",
+  "docs/onboarding.md",
+  "docs/onboarding",
+  "studio/studio.ts",
+  "studio/tsconfig.json",
+  "studio/api",
+  "studio/runner",
+  "studio/shared",
+  "studio/web",
+  "requirements.txt",
+  "omnivideo.config.example.json",
+  ".env.example",
+];
+const SKIP = [
+  /\.test\.(mjs|ts|tsx|js)$/,
+  /(^|\/)test(\/|$)/,
+  /(^|\/)__pycache__(\/|$)/,
+  /\.pyc$/,
+  /(^|\/)\.DS_Store$/,
+  /^tools\/migrate-en\.mjs$/,
+];
+
+const version = () => {
+  const v = flag("version");
+  if (v) return v;
+  const sha = spawnSync("git", ["rev-parse", "--short", "HEAD"], { cwd: CODE_ROOT, encoding: "utf8" }).stdout.trim();
+  return `0.1.0-dev.${sha || "local"}`;
+};
+
+function build() {
+  rmSync(OUT, { recursive: true, force: true });
+  mkdirSync(PKG, { recursive: true });
+  for (const entry of INCLUDE) {
+    const from = join(CODE_ROOT, entry);
+    if (!existsSync(from)) continue;
+    cpSync(from, join(PKG, entry), {
+      recursive: true,
+      filter: src => {
+        const rel = relative(CODE_ROOT, src);
+        return !SKIP.some(re => re.test(rel));
+      },
+    });
+  }
+  const studio = JSON.parse(readFileSync(join(CODE_ROOT, "studio", "package.json"), "utf8"));
+  const v = version();
+  const pkg = {
+    name: PACKAGE,
+    version: v,
+    description: "OmniVideo no seu computador: o CLI omni, o studio local e as ferramentas do pipeline.",
+    type: "module",
+    bin: { omni: "bin/omni.mjs" },
+    engines: { node: ">=22" },
+    os: ["darwin"],
+    license: "UNLICENSED",
+    homepage: "https://omni.crievo.com",
+    /* the studio's runtime libraries, plus the bun that runs it */
+    dependencies: { ...studio.dependencies, bun: "1.4.3" },
+  };
+  writeFileSync(join(PKG, "package.json"), `${JSON.stringify(pkg, null, 2)}\n`);
+  writeFileSync(
+    join(PKG, "README.md"),
+    "# @crievo/omni\n\nO CLI do OmniVideo. Use pelo plugin do Claude Code (`claude plugin install omnivideo --marketplace pedroflp/omni-plugin`) ou, sem ele, `npx -y @crievo/omni setup`.\n",
+  );
+  return v;
+}
+
+/** @param {string} dir */
+const size = dir =>
+  readdirSync(dir, { recursive: true, withFileTypes: true })
+    .filter(e => e.isFile())
+    .reduce((n, e) => n + statSync(join(e.parentPath, e.name)).size, 0);
+
+const v = build();
+const packed = spawnSync("npm", ["pack", "--pack-destination", OUT, "--loglevel=error"], {
+  cwd: PKG,
+  encoding: "utf8",
+});
+if (packed.status !== 0) fail(`npm pack falhou: ${packed.stderr.trim()}`);
+const tgz = join(OUT, packed.stdout.trim().split("\n").at(-1) ?? "");
+console.log(`${PACKAGE}@${v}: ${(size(PKG) / 1e6).toFixed(1)} MB de arquivos, pacote em ${tgz}`);
+
+if (args[0] === "publish") {
+  if (!process.env.NPM_CONFIG_USERCONFIG)
+    fail("defina NPM_CONFIG_USERCONFIG com o login da conta que publica (ex.: ~/.npmrc-pedroflp)");
+  const r = spawnSync("npm", ["publish", tgz, "--access", "public", ...(v.includes("-") ? ["--tag", "next"] : [])], {
+    stdio: "inherit",
+  });
+  if (r.status !== 0) fail("npm publish falhou");
+  console.log(`publicado: ${PACKAGE}@${v}`);
+}

package/tools/platforms.mjs

@@ -0,0 +1,236 @@
+/* ============================================================================
+   The local side of the platform clients: the credentials .env (the CLIs'
+   TokenStore) and the Instagram token bound to it. The clients themselves
+   live in tools/lib/platforms/ (pure, fetch injected); this file wires them to
+   this machine. publish.mjs, omnichat.mjs and metrics.mjs share the same
+   account: whoever renews first writes it, and the others read the new token
+   on their next call.
+   ============================================================================ */
+
+import { readFileSync, writeFileSync, renameSync } from "node:fs";
+import { join } from "node:path";
+import { request as coreRequest, sleep, DAY } from "./lib/http.mjs";
+import { igBase, instagramToken as coreInstagramToken, instagramClient } from "./lib/platforms/instagram.mjs";
+import { DATA_ROOT as ROOT } from "./lib/paths.mjs";
+
+const CFG = JSON.parse(readFileSync(join(ROOT, "omnivideo.config.json"), "utf8"));
+const ENV_FILE = join(ROOT, ".env");
+
+/* legacy PT names still found in older .env files: read as fallback, dropped on write */
+const LEGACY_ENV = {
+  INSTAGRAM_TOKEN_EXPIRES: "INSTAGRAM_TOKEN_EXPIRA",
+  TIKTOK_ACCESS_EXPIRES: "TIKTOK_ACCESS_EXPIRA",
+  TIKTOK_REFRESH_EXPIRES: "TIKTOK_REFRESH_EXPIRA",
+  TIKTOK_SCOPES: "TIKTOK_ESCOPOS",
+};
+
+/* --- .env ---------------------------------------------------------------------------
+   The Instagram and TikTok tokens renew and come back here: .env wins over the
+   environment, otherwise a stale variable in the shell would hide the new token. */
+function readEnv() {
+  /** @type {Record<string, string>} */
+  const vals = {};
+  let text = "";
+  try {
+    text = readFileSync(ENV_FILE, "utf8");
+  } catch {
+    /* no .env yet */
+  }
+  for (const line of text.split("\n")) {
+    const l = line.trim();
+    if (!l || l.startsWith("#") || !l.includes("=")) continue;
+    const i = l.indexOf("=");
+    vals[l.slice(0, i).trim()] = l
+      .slice(i + 1)
+      .trim()
+      .replace(/^["']|["']$/g, "");
+  }
+  return vals;
+}
+
+/** @param {string} name */
+export const env = name => {
+  const vals = readEnv();
+  const legacy = LEGACY_ENV[/** @type {keyof typeof LEGACY_ENV} */ (name)];
+  return vals[name] || (legacy && vals[legacy]) || process.env[name] || (legacy && process.env[legacy]) || "";
+};
+
+/** @param {Record<string, string>} values */
+export function writeEnv(values) {
+  let lines = [];
+  try {
+    lines = readFileSync(ENV_FILE, "utf8").split("\n");
+  } catch {
+    /* create */
+  }
+  const matches = (/** @type {string} */ name) => (/** @type {string} */ l) => new RegExp(`^\\s*${name}\\s*=`).test(l);
+  for (const [name, v] of Object.entries(values)) {
+    const legacy = LEGACY_ENV[/** @type {keyof typeof LEGACY_ENV} */ (name)];
+    if (legacy) lines = lines.filter(l => !matches(legacy)(l));
+    const i = lines.findIndex(matches(name));
+    if (i >= 0) lines[i] = `${name}=${v}`;
+    else {
+      while (lines.length && lines.at(-1) === "") lines.pop();
+      lines.push(`${name}=${v}`, "");
+    }
+  }
+  const tmp = `${ENV_FILE}.${process.pid}.tmp`;
+  writeFileSync(tmp, lines.join("\n"), { mode: 0o600 });
+  renameSync(tmp, ENV_FILE);
+}
+
+/* --- the cloud (cloud/omnichat: one Worker for omnichat, metrics and the schedule) ------------
+   `cloud` in the config: { url, omnichat, metrics, schedule }, each flag saying the cloud does that job
+   instead of this machine (the old omnichat.cloud { url, owns } still reads). OMNICHAT_CLOUD_SECRET in the
+   .env is the Worker's SYNC_SECRET; OMNICHAT_CLOUD_URL points at another Worker (wrangler dev, a test). */
+export function cloudSettings() {
+  const top = CFG.cloud ?? {};
+  const legacy = CFG.omnichat?.cloud ?? {};
+  const url = process.env.OMNICHAT_CLOUD_URL || top.url || legacy.url || "";
+  const secret = env("OMNICHAT_CLOUD_SECRET");
+  const ready = !!(url && secret);
+  return {
+    url: String(url).replace(/\/+$/, ""),
+    ready,
+    owns: {
+      omnichat: ready && (top.omnichat ?? legacy.owns) === true,
+      metrics: ready && top.metrics === true,
+      schedule: ready && top.schedule === true,
+    },
+    /* the hosted studio (cloud/studio): this machine connects to it as the runner */
+    studio: {
+      url: String(process.env.OMNIVIDEO_STUDIO_URL || top.studio_url || "").replace(/\/+$/, ""),
+      on: !!(process.env.OMNIVIDEO_STUDIO_URL || top.studio_url) && top.studio === true,
+    },
+  };
+}
+
+/** This Mac as the hosted studio's runner: paired? connected now? (tools/runner.mjs, omnichat.mjs status).
+ *  `configured` is false without cloud.studio_url. */
+export async function runnerStatus() {
+  const url = cloudSettings().studio.url;
+  const token = env("OMNIVIDEO_RUNNER_TOKEN");
+  const out = {
+    url: url || null,
+    configured: !!url,
+    paired: false,
+    hasKey: !!token,
+    name: /** @type {string | null} */ (null),
+    online: false,
+    error: /** @type {string | null} */ (null),
+  };
+  if (!url || !token) return out;
+  try {
+    const r = await fetch(`${url}/runner/whoami`, { headers: { authorization: `Bearer ${token}` } });
+    const body = await r.json().catch(() => ({}));
+    if (r.ok) Object.assign(out, { paired: true, name: body.name, online: !!body.online });
+    else out.error = body?.error ?? `HTTP ${r.status}`;
+  } catch (e) {
+    out.error = String(/** @type {Error} */ (e).message);
+  }
+  return out;
+}
+
+/** One call to the cloud's API; throws `cloud <method> <path>: <status> <error>` with `status`. */
+export async function cloudApi(/** @type {string} */ method, /** @type {string} */ path, /** @type {unknown} */ body) {
+  const c = cloudSettings();
+  if (!c.ready) throw new Error("cloud não configurada: cloud.url no config e OMNICHAT_CLOUD_SECRET no .env");
+  const r = await fetch(`${c.url}${path}`, {
+    method,
+    headers: { authorization: `Bearer ${env("OMNICHAT_CLOUD_SECRET")}`, "content-type": "application/json" },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  const text = await r.text();
+  let j = null;
+  try {
+    j = JSON.parse(text);
+  } catch {
+    /* not JSON */
+  }
+  if (!r.ok) {
+    /** @type {Error & { status?: number }} */
+    const e = new Error(
+      `cloud ${method} ${path}: ${r.status} ${j?.error ?? text.slice(0, 200)}${j?.problems ? `: ${j.problems.join("; ")}` : ""}`,
+    );
+    e.status = r.status;
+    throw e;
+  }
+  return j ?? {};
+}
+
+/* The cloud's copy of the Instagram token. While the cloud does any job, a token this machine renews or
+   receives goes up too, so the two never drift: Meta does not promise that
+   the token before a renewal keeps working. A failure is only a warning: `omnichat.mjs cloud push` redoes it. */
+export async function pushInstagramToken(/** @type {Record<string, string>} */ values) {
+  const c = cloudSettings();
+  if (!values.INSTAGRAM_TOKEN || !(c.owns.omnichat || c.owns.metrics || c.owns.schedule)) return;
+  try {
+    await cloudApi("PUT", "/api/account", {
+      id: values.INSTAGRAM_USER_ID || env("INSTAGRAM_USER_ID"),
+      token: values.INSTAGRAM_TOKEN,
+      expires: values.INSTAGRAM_TOKEN_EXPIRES || null,
+    });
+  } catch (e) {
+    console.error(
+      `aviso: o token novo do Instagram não subiu para a cloud (${/** @type {Error} */ (e).message}): node tools/omnichat.mjs cloud push`,
+    );
+  }
+}
+
+/* The YouTube and TikTok credentials the cloud schedule publishes with (cloud.schedule). TikTok renews
+   its refresh token too: whoever renews (here or there) passes it on, so there is one chain. */
+export async function pushPlatformEnv(/** @type {Record<string, string>} */ values) {
+  const keep = Object.fromEntries(Object.entries(values).filter(([k]) => /^(YOUTUBE|TIKTOK)_/.test(k)));
+  if (!Object.keys(keep).length || !cloudSettings().owns.schedule) return;
+  try {
+    await cloudApi("PUT", "/api/platform-env", { values: keep });
+  } catch (e) {
+    console.error(
+      `aviso: as credenciais novas não subiram para a cloud (${/** @type {Error} */ (e).message}): node tools/publish.mjs cloud push`,
+    );
+  }
+}
+
+/* Before using TikTok here while the cloud schedule renews it: the newest tokens come down first. */
+export async function pullTiktokEnv() {
+  if (!cloudSettings().owns.schedule) return;
+  try {
+    const { values } = await cloudApi("GET", "/api/platform-env/tiktok");
+    if (values?.TIKTOK_REFRESH_TOKEN) writeEnv(values);
+  } catch (e) {
+    console.error(
+      `aviso: não deu para ler os tokens do TikTok na cloud (${/** @type {Error} */ (e).message}); uso os daqui`,
+    );
+  }
+}
+
+/** The .env as the core's TokenStore. @type {import("./lib/http.mjs").TokenStore} */
+export const envStore = {
+  get: env,
+  set: async values => {
+    writeEnv(values);
+    await pushInstagramToken(values);
+    await pushPlatformEnv(values);
+  },
+};
+
+/* --- HTTP: the core's, with the global fetch ----------------------------------------- */
+/** @param {string} url @param {RequestInit} opts @param {string} label */
+export const request = (url, opts, label) => coreRequest(url, opts, label);
+export { sleep, DAY };
+
+/* --- Instagram (Instagram API with Instagram login) --------------------------------- */
+export const API_VERSION = CFG.publish?.instagram?.api_version ?? "v23.0";
+export const IG = () => igBase(API_VERSION);
+
+/* renewal warnings go to stderr, like every "aviso:" */
+const warn = (/** @type {string} */ line) => console.error(line);
+
+/** The token and the account id; renews the token here when less than 20 days are left. */
+export const instagramToken = () => coreInstagramToken({ store: envStore, warn });
+
+/** @param {string} token */
+export const instagramAccount = token => instagramClient({ token, apiVersion: API_VERSION }).account();
+
+/** An Instagram client for a token, on this machine's config. @param {string} token */
+export const igClient = token => instagramClient({ token, apiVersion: API_VERSION });