@crievo/omni 0.0.0-stage → 0.1.1

package/tools/lib/agents.mjs

@@ -0,0 +1,412 @@
+/* ============================================================================
+   The agent accounts: N Claude Code config dirs and N Codex homes
+   (`agents.accounts` in omnivideo.config.json), shared by the studio sessions
+   (studio/api/services/sessions.ts) and the tools that ask for a short text
+   (publish.mjs text, the omnichat classifier).
+
+   - Rotation: each new session goes to the next account of the list, in order;
+     a session stays on the account it runs on while that one is free.
+   - Limit: an account that hits its usage limit is set aside until it resets
+     (`.accounts/state.json`), and the work goes on in the next free one.
+   - ~/.claude (Claude Code's default account, which may be the work one) is
+     refused here, whatever the config says.
+   ============================================================================ */
+
+import { cpSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, join, resolve } from "node:path";
+
+export const PROVIDERS = ["claude", "codex"];
+export const PROVIDER_LABEL = { claude: "Claude", codex: "Codex" };
+/* the one dir no account may use */
+export const FORBIDDEN_DIR = join(homedir(), ".claude");
+/* before `agents` existed, the studio only ran here */
+export const DEFAULT_ACCOUNTS = [{ id: "claude-personal", provider: "claude", dir: "~/.claude-personal" }];
+/* the Codex CLI the ChatGPT app ships, when there is no `codex` on the PATH */
+export const CODEX_APP_BIN = "/Applications/ChatGPT.app/Contents/Resources/codex-cli/bin/codex";
+export const CODEX_DEFAULTS = { model: "gpt-6-luna", effort: "medium", sandbox: "auto" };
+/* an account whose limit came without a reset time is set aside for this long */
+const UNKNOWN_RESET_MS = 60 * 60_000;
+
+/* variables a studio opened from inside a chat inherits and the child must not */
+const INHERITED = [
+  "CLAUDECODE",
+  "CLAUDE_CODE_SESSION_ID",
+  "CLAUDE_CODE_ENTRYPOINT",
+  "CLAUDE_CONFIG_DIR",
+  "CODEX_HOME",
+  "CODEX_THREAD_ID",
+  "OMNIVIDEO_ORIGIN",
+  "OMNIVIDEO_TURN",
+];
+
+export const expandHome = p =>
+  resolve(
+    String(p ?? "")
+      .trim()
+      .replace(/^~(?=\/|$)/, homedir()),
+  );
+export const tildify = p => (p.startsWith(homedir()) ? `~${p.slice(homedir().length)}` : p);
+
+function readJson(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(file, data) {
+  mkdirSync(join(file, ".."), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(data, null, 2)}\n`);
+  renameSync(tmp, file);
+}
+
+/* --- the list ---------------------------------------------------------------- */
+
+/** what is wrong with one account, or null */
+export function accountProblem(a) {
+  if (!PROVIDERS.includes(a?.provider)) return `provedor desconhecido: ${a?.provider}`;
+  if (!String(a.dir ?? "").trim()) return "falta a pasta da conta";
+  const dir = expandHome(a.dir);
+  if (dir === FORBIDDEN_DIR || dir.startsWith(`${FORBIDDEN_DIR}/`))
+    return "o ~/.claude é a conta padrão do Claude Code (pode ser a do trabalho): o omnivideo não roda nela";
+  if (dir === homedir()) return "a pasta da conta não pode ser a home";
+  return null;
+}
+
+const slug = s =>
+  String(s)
+    .toLowerCase()
+    .replace(/^~\/?\.?/, "")
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "") || "conta";
+
+/**
+ * The accounts in order, normalized: `dir` absolute, `id` unique, the forbidden ones left out.
+ * @returns {{ id: string, provider: "claude"|"codex", dir: string, label: string, enabled: boolean }[]}
+ */
+export function accountsOf(cfg) {
+  const raw =
+    Array.isArray(cfg?.agents?.accounts) && cfg.agents.accounts.length ? cfg.agents.accounts : DEFAULT_ACCOUNTS;
+  const seen = new Set();
+  const out = [];
+  for (const a of raw) {
+    if (accountProblem(a)) continue;
+    const dir = expandHome(a.dir);
+    if (out.some(o => o.dir === dir)) continue;
+    let id = String(a.id ?? "").trim() || slug(`${a.provider}-${tildify(dir)}`);
+    while (seen.has(id)) id = `${id}-2`;
+    seen.add(id);
+    out.push({
+      id,
+      provider: a.provider,
+      dir,
+      label: String(a.label ?? "").trim() || tildify(dir),
+      enabled: a.enabled !== false,
+    });
+  }
+  return out;
+}
+
+/** checks a list the user sent and returns it ready for the config, or `{ error }` */
+export function cleanAccounts(list) {
+  if (!Array.isArray(list) || !list.length) return { error: "deixe pelo menos uma conta" };
+  const out = [];
+  for (const a of list) {
+    const problem = accountProblem(a);
+    if (problem) return { error: `${a?.label || a?.dir || "conta"}: ${problem}` };
+    const dir = expandHome(a.dir);
+    if (out.some(o => expandHome(o.dir) === dir)) return { error: `pasta repetida: ${tildify(dir)}` };
+    const entry = {
+      id: String(a.id ?? "").trim() || slug(`${a.provider}-${tildify(dir)}`),
+      provider: a.provider,
+      dir: tildify(dir),
+    };
+    while (out.some(o => o.id === entry.id)) entry.id = `${entry.id}-2`;
+    if (String(a.label ?? "").trim()) entry.label = String(a.label).trim();
+    if (a.enabled === false) entry.enabled = false;
+    out.push(entry);
+  }
+  if (!out.some(a => a.enabled !== false)) return { error: "deixe pelo menos uma conta ligada" };
+  return { accounts: out };
+}
+
+export const codexSettings = cfg => ({ ...CODEX_DEFAULTS, ...(cfg?.agents?.codex ?? {}) });
+
+/* --- login --------------------------------------------------------------------- */
+
+const jwtPayload = token => {
+  try {
+    return JSON.parse(Buffer.from(String(token).split(".")[1], "base64url").toString("utf8"));
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Who is logged in to an account, read from its own files (no process, no network).
+ * @returns {{ email: string|null, detail: string|null } | null}
+ */
+export function loginOf(a) {
+  if (a.provider === "claude") {
+    const o = readJson(join(a.dir, ".claude.json"))?.oauthAccount;
+    if (!o) return null;
+    const org =
+      o.organizationName && o.organizationName !== `${o.emailAddress}'s Organization` ? o.organizationName : null;
+    return { email: o.emailAddress ?? null, detail: org };
+  }
+  const auth = readJson(join(a.dir, "auth.json"));
+  if (!auth) return null;
+  if (auth.tokens?.id_token) {
+    const p = jwtPayload(auth.tokens.id_token);
+    const plan = p?.["https://api.openai.com/auth"]?.chatgpt_plan_type ?? null;
+    return { email: p?.email ?? null, detail: plan ? `ChatGPT ${plan}` : "ChatGPT" };
+  }
+  if (auth.OPENAI_API_KEY) return { email: null, detail: "chave de API" };
+  return null;
+}
+
+/* the command that logs an account in, for the screen and the CLI hints */
+export function loginCommand(a, cfg) {
+  const dir = tildify(a.dir);
+  return a.provider === "claude"
+    ? `CLAUDE_CONFIG_DIR=${dir} claude auth login`
+    : `CODEX_HOME=${dir} ${codexBin(cfg) === "codex" ? "codex" : `"${codexBin(cfg)}"`} login`;
+}
+
+/* --- programs and environment ---------------------------------------------------- */
+
+const onPath = name => {
+  for (const d of (process.env.PATH ?? "").split(delimiter)) {
+    if (d && existsSync(join(d, name))) return join(d, name);
+  }
+  return null;
+};
+
+export const claudeBin = cfg => cfg?.studio?.claude?.bin ?? onPath("claude") ?? "claude";
+export const codexBin = cfg =>
+  cfg?.agents?.codex?.bin ?? onPath("codex") ?? (existsSync(CODEX_APP_BIN) ? CODEX_APP_BIN : "codex");
+export const binOf = (a, cfg) => (a.provider === "claude" ? claudeBin(cfg) : codexBin(cfg));
+
+/** the child's environment: the account's dir and nothing inherited from a chat */
+export function envFor(a, base = process.env, extra = {}) {
+  const env = { ...base, ...extra };
+  for (const k of INHERITED) delete env[k];
+  if (a.provider === "claude") env.CLAUDE_CONFIG_DIR = a.dir;
+  else env.CODEX_HOME = a.dir;
+  return env;
+}
+
+/** the models a Codex account can use (its models_cache.json), the visible ones */
+export function codexModels(accounts) {
+  /* with no Codex account yet, the default home tells what there is */
+  const dirs = [...accounts.filter(x => x.provider === "codex").map(a => a.dir), join(homedir(), ".codex")];
+  for (const dir of dirs) {
+    const list = readJson(join(dir, "models_cache.json"))?.models;
+    if (Array.isArray(list) && list.length)
+      return list
+        .filter(m => m.visibility !== "hide")
+        .map(m => ({
+          id: m.slug,
+          label: m.display_name ?? m.slug,
+          efforts: (m.supported_reasoning_levels ?? []).map(e => e.effort),
+        }));
+  }
+  return [];
+}
+
+/* --- limits and rotation ----------------------------------------------------------- */
+
+const stateFile = root => join(root, ".accounts", "state.json");
+export const readState = root => ({ next: 0, limited: {}, ...(readJson(stateFile(root)) ?? {}) });
+
+/** when an account is free again (ms), or 0 when it is free now */
+export function limitedUntil(root, id, now = Date.now()) {
+  const until = readState(root).limited?.[id]?.until ?? 0;
+  return until > now ? until : 0;
+}
+
+/**
+ * @param {string} root @param {string} id @param {number|null|undefined} until
+ * @param {string|null} [reason] @param {number} [now]
+ */
+export function markLimited(root, id, until, reason = null, now = Date.now()) {
+  const s = readState(root);
+  s.limited = { ...s.limited, [id]: { until: until && until > now ? until : now + UNKNOWN_RESET_MS, at: now, reason } };
+  writeJson(stateFile(root), s);
+  return s.limited[id].until;
+}
+
+export function clearLimit(root, id) {
+  const s = readState(root);
+  if (!s.limited?.[id]) return false;
+  delete s.limited[id];
+  writeJson(stateFile(root), s);
+  return true;
+}
+
+/** an account that can take work now: on, logged in and not over its limit */
+export const isReady = (root, a, now = Date.now()) => a.enabled && !!loginOf(a) && !limitedUntil(root, a.id, now);
+
+/**
+ * The next account of the rotation that can take work, skipping `exclude` (ids), or null.
+ * `advance`: move the rotation past it (a new session); off to only look.
+ * @param {string} root @param {any} cfg
+ * @param {{ exclude?: string[], advance?: boolean, now?: number }} [opts]
+ */
+export function pickAccount(root, cfg, { exclude = [], advance = true, now = Date.now() } = {}) {
+  const all = accountsOf(cfg);
+  if (!all.length) return null;
+  const s = readState(root);
+  const start = (((s.next ?? 0) % all.length) + all.length) % all.length;
+  for (let k = 0; k < all.length; k++) {
+    const i = (start + k) % all.length;
+    const a = all[i];
+    if (exclude.includes(a.id) || !isReady(root, a, now)) continue;
+    if (advance) writeJson(stateFile(root), { ...readState(root), next: i + 1 });
+    return a;
+  }
+  return null;
+}
+
+/** why no account can take work, in Portuguese, for the screen */
+export function noAccountReason(root, cfg, now = Date.now()) {
+  const all = accountsOf(cfg).filter(a => a.enabled);
+  if (!all.length) return "nenhuma conta de agente ligada (Configurações → Agente de IA)";
+  if (!all.some(a => loginOf(a))) return "nenhuma conta de agente com login (Configurações → Agente de IA)";
+  const soonest = Math.min(
+    ...all
+      .filter(a => loginOf(a))
+      .map(a => limitedUntil(root, a.id, now))
+      .filter(Boolean),
+  );
+  const at = new Date(soonest).toLocaleString("pt-BR", { weekday: "short", hour: "2-digit", minute: "2-digit" });
+  return `todas as contas de agente bateram o limite de uso; a primeira libera ${at}`;
+}
+
+/* --- limit detection ----------------------------------------------------------------- */
+
+const LIMIT_TEXT =
+  /hit your (session |weekly |usage |daily )?limit|usage limit|usage_limit|rate.?limit|too many requests|quota|\b429\b/i;
+export const isLimitText = text => LIMIT_TEXT.test(String(text ?? ""));
+
+/** a reset time (ms) inside a Codex error, when it brings one */
+export function codexResetOf(text, now = Date.now()) {
+  const s = String(text ?? "");
+  const secs = /"?resets_in_seconds"?\s*[:=]\s*(\d+)/.exec(s);
+  if (secs) return now + Number(secs[1]) * 1000;
+  const at = /"?resets_at"?\s*[:=]\s*(\d{9,13})/.exec(s);
+  if (at) return Number(at[1]) * (at[1].length <= 10 ? 1000 : 1);
+  const rel = /try again in\s+(?:(\d+)\s*days?)?[\s,]*(?:(\d+)\s*hours?)?[\s,]*(?:(\d+)\s*min)/i.exec(s);
+  if (rel) return now + (((+rel[1] || 0) * 24 + (+rel[2] || 0)) * 60 + (+rel[3] || 0)) * 60_000;
+  return null;
+}
+
+/* --- Claude's transcript, copied to another account -------------------------------- */
+
+/* Claude Code keeps a session at <dir>/projects/<cwd with every non-alphanumeric as ->/<id>.jsonl */
+export const claudeProjectDir = (dir, cwd) => join(dir, "projects", cwd.replace(/[^a-zA-Z0-9]/g, "-"));
+
+/** copies a Claude session (and its subagents) from one account to another, so --resume works there */
+export function copyClaudeSession(from, to, cwd, id) {
+  const src = claudeProjectDir(from.dir, cwd);
+  const dst = claudeProjectDir(to.dir, cwd);
+  if (!existsSync(join(src, `${id}.jsonl`))) return false;
+  mkdirSync(dst, { recursive: true });
+  cpSync(join(src, `${id}.jsonl`), join(dst, `${id}.jsonl`));
+  if (existsSync(join(src, id))) cpSync(join(src, id), join(dst, id), { recursive: true });
+  return true;
+}
+
+/* --- a short text (no tools, one answer) -------------------------------------------- */
+
+/**
+ * The command for one short answer on an account: the prompt as argument, `input` on stdin.
+ * Codex writes its last message to `outFile` (its stdout is the progress).
+ */
+export function textCommand(a, cfg, { prompt, claudeModel, outFile }) {
+  if (a.provider === "claude")
+    return [claudeBin(cfg), ["-p", prompt, ...(claudeModel ? ["--model", claudeModel] : []), "--max-turns", "1"]];
+  const c = codexSettings(cfg);
+  return [
+    codexBin(cfg),
+    [
+      "exec",
+      "--ephemeral",
+      "--skip-git-repo-check",
+      /* the user's config.toml brings MCP servers and a model that may not exist: not needed for a text */
+      "--ignore-user-config",
+      "-s",
+      "read-only",
+      "-m",
+      c.text_model ?? c.model,
+      "-c",
+      `model_reasoning_effort="${c.text_effort ?? "low"}"`,
+      "-o",
+      outFile,
+      prompt,
+    ],
+  ];
+}
+
+const tail = s =>
+  String(s ?? "")
+    .trim()
+    .slice(-300);
+
+/** the outcome of one run: `{ text }`, `{ limited, until }` or `{ error }` */
+export function textOutcome(a, { status, stdout, stderr, error, outFile }) {
+  if (error) return { error: `${a.provider}: ${error.message ?? error}` };
+  const said = `${stdout ?? ""}\n${stderr ?? ""}`;
+  if (status !== 0) {
+    if (isLimitText(said))
+      return { limited: true, until: a.provider === "codex" ? codexResetOf(said) : null, error: tail(said) };
+    return { error: `${a.provider} saiu com ${status}: ${tail(said)}` };
+  }
+  if (a.provider === "claude") return { text: String(stdout ?? "") };
+  try {
+    return { text: readFileSync(outFile, "utf8") };
+  } catch {
+    return { error: "codex não escreveu a resposta" };
+  }
+}
+
+/* One short answer, trying the accounts in rotation: one that hits its limit is set aside and
+   the next one answers. A generator so the same loop serves a sync and an async spawn: it yields
+   `{ bin, args, env }` and takes back `{ status, stdout, stderr, error }`. */
+function* askSteps({ root, cfg, prompt, claudeModel, tmpDir }) {
+  const tried = [];
+  let last = null;
+  for (;;) {
+    const a = pickAccount(root, cfg, { exclude: tried });
+    if (!a) break;
+    tried.push(a.id);
+    const outFile = join(tmpDir, `answer-${process.pid}-${Date.now()}.txt`);
+    const [bin, args] = textCommand(a, cfg, { prompt, claudeModel, outFile });
+    const res = yield { bin, args, env: envFor(a) };
+    const o = textOutcome(a, { ...res, outFile });
+    if (o.text != null) return { text: o.text, account: a };
+    if (!o.limited) throw new Error(o.error);
+    markLimited(root, a.id, o.until, o.error);
+    last = o.error;
+  }
+  throw new Error(last ?? noAccountReason(root, cfg));
+}
+
+/** `run(bin, args, env)` → `{ status, stdout, stderr, error }`, synchronously (spawnSync) */
+export function askTextSync(o, run) {
+  const g = askSteps(o);
+  let s = g.next();
+  while (!s.done) s = g.next(run(s.value.bin, s.value.args, s.value.env));
+  return s.value;
+}
+
+/** the same with an async `run` (spawn) */
+export async function askText(o, run) {
+  const g = askSteps(o);
+  let s = g.next();
+  while (!s.done) s = g.next(await run(s.value.bin, s.value.args, s.value.env));
+  return s.value;
+}