CenaForge: primeira versão pública

Gerador de vídeos narrativos (Godot + FFmpeg), painel Next.js, serviço de voz,
Clipador de lives e Publicador para YouTube, TikTok e Instagram.

Inclui a leitura das visualizações dos posts para o Dashboard e o botão
"Publicar no <rede>" nos cartões das publicações.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-17 16:35:09 -03:00
co-authored by Claude Opus 5.5
commit 84f30bbc2d
484 changed files with 74826 additions and 0 deletions
+539
View File
@@ -0,0 +1,539 @@
// Agentes de código (Claude Code e Codex) chamados pela CLI, como no VS Code.
//
// Segurança (decisão do usuário: "edita sozinho no projeto"):
// - roda com cwd = raiz do repositório; edições automáticas só dentro dele;
// - Bash só para os comandos liberados abaixo (render, testes, scripts da skill);
// - o pedido vai como argumento (sem shell); stdin fechado;
// - um agente por vez; cancelar encerra a árvore de processos.
// Comentários do público NUNCA entram no prompt: só a decisão A/B já fechada.
import { spawn, spawnSync, type ChildProcess } from "node:child_process";
import fs from "node:fs";
import path from "node:path";
import { all, get, now, run } from "./db";
import { DATA_DIR, REPO_ROOT, rel } from "./paths";
import { buildPrompt } from "./prompts";
import { findOnPath, killTree, lineSplitter } from "./proc";
import { onAgentRunClosed } from "./branches";
import { UserError, getEpisodeById, getStory, syncStoryMeta } from "./stories";
import { AGENT_KINDS, type AgentEvent, type AgentKind, type AgentRun, type Provider } from "./types";
const SKILL_SCRIPTS = "python .claude/skills/cenaforge/scripts";
export const CLAUDE_ALLOWED_TOOLS = [
"Read", "Edit", "Write", "Glob", "Grep", "Agent", "Skill", "TodoWrite",
"Bash(pnpm render:*)", "Bash(pnpm verify:*)", "Bash(pnpm test:*)", "Bash(pnpm typecheck)",
"Bash(pnpm run doctor)", "Bash(pnpm prepare-assets)",
`Bash(${SKILL_SCRIPTS}/new_scene.py:*)`, `Bash(${SKILL_SCRIPTS}/runs_summary.py:*)`,
`Bash(${SKILL_SCRIPTS}/inspect_strip.py:*)`, `Bash(${SKILL_SCRIPTS}/check_skill.py:*)`, `Bash(${SKILL_SCRIPTS}/godot_api.py:*)`,
`Bash(${SKILL_SCRIPTS}/frame_check.py:*)`, `Bash(${SKILL_SCRIPTS}/check_script.py:*)`,
].join(",");
/**
* Economia de tokens: sem estas flags, o `claude -p` do painel carregava a cada turno os plugins,
* MCPs, hooks, skills e agentes da instalação do usuário (61 ferramentas, 310 skills, 78 agentes).
* Medido com o mesmo prompt trivial (17/11/2026): 62,4 mil → 14,9 mil tokens de entrada no 1º turno,
* partida de 8,0 s → 4,3 s. Valem só para os agentes do painel; a config global não muda.
* - `--setting-sources project,local`: ignora ~/.claude/settings.json (plugins e hooks do usuário).
* O login não depende dele. O .claude/ do projeto (skills, subagentes) continua valendo.
* - `--strict-mcp-config` sem `--mcp-config`: nenhum servidor MCP.
* - `--tools`: só as ferramentas que as tarefas usam (Agent = subagente roteirista; Skill = cenaforge).
*/
const CLAUDE_TOOLS = "Read,Edit,Write,Glob,Grep,Bash,Agent,Skill,TodoWrite";
const CLAUDE_LEAN_FLAGS = ["--setting-sources", "project,local", "--strict-mcp-config", "--tools", CLAUDE_TOOLS];
/**
* Teto de gasto por execução do Claude (US$), proteção contra laço. Folgado: a cena no Godot
* custou US$ 3,09 no Opus e o padrão agora é o Sonnet. Ao atingir, a CLI encerra a execução e o
* usuário pode continuar a conversa pelo painel.
*/
export const CLAUDE_BUDGET_USD: Record<AgentKind, number> = { story: 1.5, script: 1.5, branches: 2.5, scene: 1, godot: 3, free: 3 };
export type ModelOption = { id: string; label: string };
/** Modelos do Claude Code (ids aceitos por `claude --model`). "" = o padrão configurado na CLI. */
const CLAUDE_MODELS: ModelOption[] = [
{ id: "", label: "Padrão da CLI" },
{ id: "claude-fable-5-2", label: "Fable 5.2" },
{ id: "claude-opus-5-5", label: "Opus 5.5: mais capaz, mais caro" },
{ id: "claude-sonnet-5-5", label: "Sonnet 5.5: equilíbrio entre roteiro e cena" },
{ id: "claude-haiku-5-5", label: "Haiku 5.5: mais barato, para variações e resumos" },
];
/** Apelidos que execuções antigas gravaram; continuam aceitos ao retomar uma conversa. */
const CLAUDE_ALIASES = ["opus", "sonnet", "haiku"];
const CODEX_HOME = process.env.CODEX_HOME || path.join(process.env.USERPROFILE || process.env.HOME || "", ".codex");
/**
* Modelos do Codex: a própria CLI guarda em ~/.codex/models_cache.json os modelos que a conta
* enxerga (atualizado a cada uso da CLI). Só os visíveis no seletor da CLI ("list"), na ordem dela.
* O padrão é o `model = "..."` do config.toml.
*/
function codexModels(): ModelOption[] {
let configured = "";
try {
configured = /^\s*model\s*=\s*"([^"]+)"/m.exec(fs.readFileSync(path.join(CODEX_HOME, "config.toml"), "utf8"))?.[1] ?? "";
} catch { /* sem config: a CLI usa o padrão dela */ }
type CachedModel = { slug?: unknown; display_name?: unknown; description?: unknown; visibility?: unknown; priority?: unknown };
let cached: CachedModel[] = [];
try {
const parsed = JSON.parse(fs.readFileSync(path.join(CODEX_HOME, "models_cache.json"), "utf8")) as { models?: unknown };
if (Array.isArray(parsed.models)) cached = parsed.models as CachedModel[];
} catch { /* cache ausente: só o padrão */ }
const listed = cached
.filter((m) => typeof m.slug === "string" && m.visibility === "list")
.sort((a, b) => Number(a.priority ?? 99) - Number(b.priority ?? 99))
.map((m) => {
const name = typeof m.display_name === "string" ? m.display_name : String(m.slug);
const about = typeof m.description === "string" && m.description ? `: ${m.description}` : "";
return { id: String(m.slug), label: `${name}${about}` };
});
const defaultName = listed.find((m) => m.id === configured)?.label.split(":")[0] ?? configured;
return [{ id: "", label: defaultName ? `Padrão da CLI (${defaultName})` : "Padrão da CLI" }, ...listed];
}
/** Modelos que o seletor oferece por agente. */
export function models(): Record<Provider, ModelOption[]> {
return { claude: CLAUDE_MODELS, codex: codexModels() };
}
/** Modelo sugerido por tipo de tarefa (economia de tokens). */
// Vertentes: roteiro + cena de 2–4 episódios numa execução só → Sonnet (qualidade de roteiro sem o custo do Opus).
// Cena no Godot: Sonnet (a cena dos náufragos no Opus custou US$ 3,09 e esgotou o limite de 5 h em 11 min).
export const DEFAULT_MODEL: Record<AgentKind, string> = { free: "", story: "", script: "", scene: "claude-sonnet-5-5", branches: "claude-sonnet-5-5", godot: "claude-sonnet-5-5" };
/**
* Agente preferido por tarefa (decisão do usuário: enredo e roteiro com GPT, via Codex).
* Se o preferido não estiver disponível, cai para o outro.
*/
export const PREFERRED_PROVIDER: Record<AgentKind, Provider> = { free: "claude", story: "codex", script: "codex", scene: "claude", branches: "codex", godot: "claude" };
export function defaultProviderFor(kind: AgentKind): Provider {
const list = providers();
const preferred = PREFERRED_PROVIDER[kind];
if (list.find((p) => p.id === preferred)?.available) return preferred;
return list.find((p) => p.available)?.id ?? preferred;
}
/** Modelo padrão: o do tipo de tarefa só vale para o Claude; no Codex, o do config.toml. */
export function defaultModelFor(kind: AgentKind, provider: Provider): string {
return provider === "claude" ? DEFAULT_MODEL[kind] : CODEX_DEFAULT_MODEL[kind];
}
/**
* Codex por tarefa (economia): texto e roteiro com o modelo de uso geral (GPT-6.1-Sol), não o
* "frontier" do config.toml (GPT-6-Astra, o mais caro). "" = o padrão do config.toml. Só vale se o
* modelo existir na lista da CLI; senão cai no padrão.
*/
const CODEX_DEFAULT_MODEL: Record<AgentKind, string> = { free: "", story: "gpt-6.1-sol", script: "gpt-6.1-sol", branches: "gpt-6.1-sol", scene: "", godot: "" };
/** `command` + `prefixArgs` é o que de fato executamos (ex.: node + codex.js no Windows). */
type ProviderInfo = {
id: Provider; available: boolean; path: string | null; version: string | null; note: string;
command: string | null; prefixArgs: string[];
};
/**
* Execução em andamento. `followUp`: mensagem do usuário enviada durante a execução; quando ela
* fecha (sozinha ou interrompida), a mesma sessão é retomada com essa mensagem.
*/
type ActiveRun = {
child: ChildProcess;
listeners: Set<(e: AgentEvent | null) => void>;
emit: (e: Omit<AgentEvent, "at">) => void;
followUp: string | null;
/** O agente já deu um passo (texto ou ferramenta). Antes disso a sessão ainda não guardou o pedido. */
progressed: boolean;
};
const g = globalThis as unknown as { __cenaforgeAgents?: Map<number, ActiveRun>; __cenaforgeProviders?: { at: number; list: ProviderInfo[] } };
const active = (g.__cenaforgeAgents ??= new Map());
/** Há um agente trabalhando? (o executor roda um por vez) */
export function busy(): boolean {
return active.size > 0;
}
/**
* Executável de um provedor. No Windows o npm instala o Codex como `codex.cmd` (que o Node
* não executa sem shell); nesse caso rodamos o `codex.js` do pacote diretamente pelo Node.
*/
function resolveCommand(id: Provider, envVar: string): { path: string; command: string; prefixArgs: string[] } | null {
const fromEnv = process.env[envVar];
if (fromEnv) {
return fromEnv.endsWith(".js")
? { path: fromEnv, command: process.execPath, prefixArgs: [fromEnv] }
: { path: fromEnv, command: fromEnv, prefixArgs: [] };
}
const exe = findOnPath(id);
if (exe) return { path: exe, command: exe, prefixArgs: [] };
if (id === "codex") {
for (const dir of (process.env.PATH ?? "").split(path.delimiter).filter(Boolean)) {
const js = path.join(dir, "node_modules", "@openai", "codex", "bin", "codex.js");
if (fs.existsSync(path.join(dir, "codex.cmd")) && fs.existsSync(js)) {
return { path: js, command: process.execPath, prefixArgs: [js] };
}
}
}
return null;
}
export function providers(): ProviderInfo[] {
// Cache curto: instalar ou remover uma CLI aparece sem reiniciar o painel.
if (g.__cenaforgeProviders && Date.now() - g.__cenaforgeProviders.at < 60_000) return g.__cenaforgeProviders.list;
const detect = (id: Provider, envVar: string, note: string): ProviderInfo => {
const resolved = resolveCommand(id, envVar);
let version: string | null = null;
if (resolved) {
const r = spawnSync(resolved.command, [...resolved.prefixArgs, "--version"], { encoding: "utf8", timeout: 20_000, windowsHide: true, shell: false });
version = r.status === 0 ? r.stdout.trim().split(/\r?\n/)[0] : null;
}
return {
id, available: !!resolved && version !== null, path: resolved?.path ?? null, version,
note: resolved ? note : `${note} Não encontrado: instale e faça login${id === "codex" ? " (npm install -g @openai/codex; codex login)" : ""}.`,
command: resolved?.command ?? null, prefixArgs: resolved?.prefixArgs ?? [],
};
};
const list = [
detect("claude", "CLAUDE_BIN", "Claude Code CLI em modo não interativo (-p, stream-json); edição automática dentro do projeto e comandos liberados."),
detect("codex", "CODEX_BIN", "Codex CLI (codex exec --json) com sandbox workspace-write: escreve só dentro do projeto."),
];
g.__cenaforgeProviders = { at: Date.now(), list };
return list;
}
export function listRuns(limit = 30): AgentRun[] {
return all<AgentRun>("SELECT * FROM agent_runs ORDER BY id DESC LIMIT ?", limit);
}
export function getRun(id: number): AgentRun | undefined {
return get<AgentRun>("SELECT * FROM agent_runs WHERE id = ?", id);
}
export function startRun(input: {
provider: Provider; model: string; kind: AgentKind; request: string;
storyId?: string | null; episodeId?: number | null; resumeRunId?: number | null;
}): AgentRun {
const info = providers().find((p) => p.id === input.provider);
if (!info?.available || !info.command) throw new UserError(`${input.provider} não está disponível neste computador.`);
if (active.size > 0) throw new UserError("Já existe um agente trabalhando. Aguarde ou cancele antes de enviar outro pedido.");
const request = input.request.trim();
if (request.length < 2) throw new UserError("Escreva o pedido.");
if (request.length > 20_000) throw new UserError("Pedido longo demais (máx. 20 mil caracteres).");
if (!AGENT_KINDS.includes(input.kind)) throw new UserError("Tipo de tarefa inválido.");
const knownModel = models()[input.provider].some((m) => m.id === input.model) ||
(input.provider === "claude" && CLAUDE_ALIASES.includes(input.model));
if (input.model && !knownModel) throw new UserError("Modelo inválido para este agente.");
const story = input.storyId ? getStory(input.storyId) : undefined;
if (input.storyId && !story) throw new UserError("História não encontrada.");
const episode = input.episodeId ? getEpisodeById(input.episodeId) : undefined;
if (input.episodeId && (!episode || episode.story_id !== story?.id)) throw new UserError("Episódio não pertence à história.");
const resume = input.resumeRunId ? getRun(input.resumeRunId) : undefined;
if (input.resumeRunId && (!resume?.session_id || resume.provider !== input.provider)) {
throw new UserError("Só é possível continuar uma conversa do mesmo agente, com sessão registrada.");
}
const prompt = resume ? request : buildPrompt({ kind: input.kind, provider: input.provider, request, story, episode });
const logDir = path.join(DATA_DIR, "logs", "agents");
fs.mkdirSync(logDir, { recursive: true });
const row = run(`INSERT INTO agent_runs (provider, model, kind, prompt, story_id, episode_id, resume_of, status, log_path, started_at)
VALUES (?, ?, ?, ?, ?, ?, ?, 'running', '', ?)`,
input.provider, input.model, input.kind, request, story?.id ?? null, episode?.id ?? null, resume?.id ?? null, now());
const id = Number(row.lastInsertRowid);
const logPath = path.join(logDir, `${id}.jsonl`);
run("UPDATE agent_runs SET log_path = ? WHERE id = ?", rel(logPath), id);
const args = input.provider === "claude"
? ["-p", prompt, "--output-format", "stream-json", "--verbose", "--permission-mode", "acceptEdits",
...(input.model ? ["--model", input.model] : []),
...(resume?.session_id ? ["--resume", resume.session_id] : []),
...CLAUDE_LEAN_FLAGS, "--max-budget-usd", String(CLAUDE_BUDGET_USD[input.kind]),
"--allowedTools", CLAUDE_ALLOWED_TOOLS]
: codexArgs(prompt, input.model, resume?.session_id ?? null, input.kind);
const child = spawn(info.command, [...info.prefixArgs, ...args], { cwd: REPO_ROOT, shell: false, windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
const listeners = new Set<(e: AgentEvent | null) => void>();
const log = fs.createWriteStream(logPath);
const emit = (e: Omit<AgentEvent, "at">) => {
if (e.kind !== "system" && e.kind !== "stderr" && e.kind !== "error") entry.progressed = true;
const event = { ...e, at: now() } as AgentEvent;
log.write(JSON.stringify(event) + "\n");
for (const l of listeners) l(event);
};
const entry: ActiveRun = { child, listeners, emit, followUp: null, progressed: false };
active.set(id, entry);
emit({ kind: "system", text: `${input.provider}${input.model ? ` · ${input.model}` : ""} · tarefa "${input.kind}"${resume ? ` · continua a execução #${resume.id}` : ""}` });
child.stdout.setEncoding("utf8").on("data", lineSplitter((line) => {
let obj: Record<string, unknown>;
try {
obj = JSON.parse(line);
} catch {
emit({ kind: "text", text: line.slice(0, 2000) });
return;
}
const events = input.provider === "claude" ? normalizeClaude(obj, id) : normalizeCodex(obj, id);
events.forEach(emit);
}));
child.stderr.setEncoding("utf8").on("data", lineSplitter((line) => {
if (!STDERR_NOISE.some((re) => re.test(line))) emit({ kind: "stderr", text: line.slice(0, 1000) });
}));
child.on("error", (error) => emit({ kind: "error", text: `não iniciou: ${error.message}`, isError: true }));
child.on("close", (code) => {
// Tarefa "criar história": a IA grava meta.json com título e premissa definitivos.
if (input.kind === "story" && story && code === 0) syncStoryMeta(story.id);
const current = getRun(id);
if (current?.status === "running") {
const ok = code === 0 && !current.error;
run("UPDATE agent_runs SET status = ?, error = COALESCE(error, ?), finished_at = ? WHERE id = ?",
ok ? "success" : "error", ok ? null : `saiu com código ${code}`, now(), id);
}
active.delete(id);
// Vertentes: fecha o preparo desta execução e começa o próximo da fila (o executor já está livre).
try {
onAgentRunClosed(id, getRun(id)?.status === "success");
} catch (error) {
console.warn(`vertentes após a execução #${id}: ${(error as Error).message}`);
}
// Mensagem enviada durante a execução: retoma a mesma sessão com ela. Começa ANTES de avisar
// os ouvintes, para o evento "end" já levar o id da continuação (o console segue para ela).
if (entry.followUp) {
const closed = getRun(id);
try {
if (!closed?.session_id) throw new UserError("o agente não registrou a sessão, então não dá para continuar a conversa");
startRun({
provider: closed.provider, model: closed.model, kind: closed.kind, request: entry.followUp,
storyId: closed.story_id, episodeId: closed.episode_id, resumeRunId: id,
});
} catch (error) {
emit({ kind: "error", text: `Sua mensagem não foi enviada: ${(error as Error).message}. Copie-a e envie de novo.`, isError: true });
}
}
for (const l of listeners) l(null);
log.end();
});
return getRun(id)!;
}
/**
* Mensagem do usuário durante a execução.
* - "now": interrompe o agente e retoma a mesma sessão com a correção (ele vê o que já fez);
* - "queue": espera o agente terminar e então continua a conversa com a mensagem.
* Uma mensagem por vez: a nova substitui a que estava na fila.
*/
export function sendFollowUp(id: number, text: string, mode: "now" | "queue"): void {
const entry = active.get(id);
if (!entry) throw new UserError("Esta execução já terminou. Use \"Continuar esta conversa\".");
const message = text.trim();
if (message.length < 2) throw new UserError("Escreva a mensagem.");
if (message.length > 20_000) throw new UserError("Mensagem longa demais (máx. 20 mil caracteres).");
const current = getRun(id);
// Testado com o Codex: interrompido antes do primeiro passo, a sessão retomada não tem o pedido original.
if (mode === "now" && (!current?.session_id || !entry.progressed)) {
throw new UserError("O agente ainda está começando. Aguarde o primeiro passo dele ou use \"Enviar ao terminar\".");
}
entry.followUp = mode === "now"
? `O usuário interrompeu você para corrigir o rumo. Considere o que já foi feito até aqui e siga esta orientação:\n\n${message}`
: `Mensagem do usuário enviada enquanto você trabalhava:\n\n${message}`;
entry.emit({ kind: "system", text: mode === "now" ? "Interrompido para receber sua correção." : "Sua mensagem será enviada quando o agente terminar." });
if (mode === "now") {
run("UPDATE agent_runs SET status = 'cancelled', error = COALESCE(error, ?), finished_at = ? WHERE id = ?", "interrompida para correção", now(), id);
killTree(entry.child);
}
}
/** A execução que continuou esta (mensagem enviada durante ela ou "Continuar esta conversa"). */
export function followUpRunOf(id: number): number | null {
return get<{ id: number }>("SELECT id FROM agent_runs WHERE resume_of = ? ORDER BY id DESC LIMIT 1", id)?.id ?? null;
}
export function cancelRun(id: number): void {
const entry = active.get(id);
if (!entry) throw new UserError("Esta execução não está em andamento.");
run("UPDATE agent_runs SET status = 'cancelled', finished_at = ? WHERE id = ?", now(), id);
killTree(entry.child);
}
export function isActive(id: number): boolean {
return active.has(id);
}
/** Inscreve-se nos eventos ao vivo; o callback recebe null quando termina. */
export function subscribe(id: number, listener: (e: AgentEvent | null) => void): () => void {
const entry = active.get(id);
if (!entry) return () => {};
entry.listeners.add(listener);
return () => entry.listeners.delete(listener);
}
export function readEvents(id: number): AgentEvent[] {
const r = getRun(id);
if (!r) return [];
try {
return fs.readFileSync(path.join(REPO_ROOT, r.log_path), "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l) as AgentEvent);
} catch {
return [];
}
}
// --- Codex ----------------------------------------------------------------------
/**
* Esforço de raciocínio por tarefa (o config.toml do usuário usa "high"). Medido: o roteiro (#6)
* gastou só 857 tokens de raciocínio, então "low" quase não economizaria e arriscaria a pesquisa
* de fatos; fica "medium". A cena no Godot (#8) gastou 14,5 mil: "medium". A cena JSON só roda
* um script: "low". "" = o do config.toml.
*/
const CODEX_EFFORT: Record<AgentKind, string> = { story: "medium", script: "medium", branches: "medium", godot: "medium", scene: "low", free: "" };
/** Plugins do Codex que não servem ao repositório: o de computer-use põe a ferramenta `cua_repl` (~6,5 mil caracteres) em todo turno. */
const CODEX_UNUSED_PLUGINS = ["computer-use@openai-bundled", "unified-computer-use@openai-bundled"];
/**
* Overrides `-c` só para as execuções do painel (a config global não muda): esforço por tarefa,
* servidores MCP pessoais do config.toml desligados e plugins de computer-use fora.
* Obs.: `-c mcp_servers={}` não funciona (o Codex mescla tabelas); é preciso `enabled=false` por servidor.
*/
function codexLeanOverrides(kind: AgentKind): string[] {
const overrides: string[] = [];
if (CODEX_EFFORT[kind]) overrides.push(`model_reasoning_effort="${CODEX_EFFORT[kind]}"`);
let config = "";
try { config = fs.readFileSync(path.join(CODEX_HOME, "config.toml"), "utf8"); } catch { /* sem config: nada a desligar */ }
const servers = new Set([...config.matchAll(/^\s*\[mcp_servers\.("?)([A-Za-z0-9_-]+)\1\]\s*$/gm)].map((m) => m[2]));
for (const name of servers) overrides.push(`mcp_servers.${name}.enabled=false`);
for (const plugin of CODEX_UNUSED_PLUGINS) {
if (config.includes(`[plugins."${plugin}"]`)) overrides.push(`plugins."${plugin}".enabled=false`);
}
return overrides.flatMap((o) => ["-c", o]);
}
/**
* Flags reais do codex-cli 0.169.0. O repositório não é Git, por isso --skip-git-repo-check.
* A retomada (`exec resume`) não aceita --sandbox nem -C: o sandbox vai por -c e o diretório
* é o cwd do processo (raiz do repositório).
*/
function codexArgs(prompt: string, model: string, sessionId: string | null, kind: AgentKind): string[] {
const common = ["--json", "--skip-git-repo-check", ...(model ? ["-m", model] : []), ...codexLeanOverrides(kind)];
return sessionId
? ["exec", "resume", ...common, "-c", 'sandbox_mode="workspace-write"', sessionId, prompt]
: ["exec", ...common, "--sandbox", "workspace-write", "-C", REPO_ROOT, prompt];
}
/** Linhas de stderr que não ajudam o usuário (aviso de stdin, MCP pessoal do Codex fora do ar, config pessoal do Codex). */
const STDERR_NOISE = [/no stdin data received/, /Reading additional input from stdin/, /rmcp::transport/, /Codex is ignoring \d+ unrecognized configuration setting/,
// O Claude Code avisa de id fora da lista interna dele, mas roda o modelo normalmente (testado com claude-fable-5-2).
/\[claude-code:unrecognized_model\]/];
// --- normalização ---------------------------------------------------------------
type Block = { type?: string; text?: string; name?: string; input?: Record<string, unknown>; content?: unknown; is_error?: boolean };
function normalizeClaude(o: Record<string, unknown>, runId: number): Omit<AgentEvent, "at">[] {
switch (o.type) {
case "system":
if (o.subtype === "init") {
run("UPDATE agent_runs SET session_id = ? WHERE id = ?", String(o.session_id), runId);
return [{ kind: "system", text: `sessão iniciada · modelo ${o.model}` }];
}
return [];
case "assistant":
return ((o.message as { content?: Block[] })?.content ?? []).flatMap((c): Omit<AgentEvent, "at">[] => {
if (c.type === "text" && c.text?.trim()) return [{ kind: "text", text: c.text }];
if (c.type === "tool_use") return [{ kind: "tool", text: `${c.name} ${summarizeInput(c.input)}` }];
return [];
});
case "user":
return ((o.message as { content?: Block[] | string })?.content instanceof Array
? (o.message as { content: Block[] }).content : [])
.filter((c) => c.type === "tool_result")
.map((c) => ({ kind: "tool_result" as const, text: truncate(stringify(c.content), 1500), isError: !!c.is_error }));
case "result": {
const denials = (o.permission_denials as unknown[] | undefined)?.length ?? 0;
run(`UPDATE agent_runs SET cost_usd = ?, num_turns = ?, result = ?, error = ?, session_id = COALESCE(session_id, ?)
WHERE id = ?`, Number(o.total_cost_usd ?? 0), Number(o.num_turns ?? 0), String(o.result ?? "").slice(0, 20_000),
// Erro com subtype "success" (ex.: limite de uso) traz o motivo em "result": guarde o texto.
o.is_error
? (o.subtype === "error_max_budget_usd"
? "Parou no teto de gasto desta tarefa (--max-budget-usd). Continue a conversa para seguir."
: o.subtype && o.subtype !== "success" ? String(o.subtype) : String(o.result ?? "erro").slice(0, 500))
: null,
String(o.session_id ?? ""), runId);
return [{
kind: "result", text: `${o.is_error ? "Terminou com erro" : "Concluído"} · ${o.num_turns} turnos · US$ ${Number(o.total_cost_usd ?? 0).toFixed(4)}` +
(denials ? ` · ${denials} ação(ões) bloqueada(s) pelas permissões` : ""),
isError: !!o.is_error, costUsd: Number(o.total_cost_usd ?? 0), turns: Number(o.num_turns ?? 0),
}];
}
default:
return [];
}
}
type CodexItem = {
type?: string; text?: string; message?: string; command?: string; aggregated_output?: string;
exit_code?: number | null; status?: string; changes?: { path?: string; kind?: string }[];
server?: string; tool?: string; query?: string;
};
/** Eventos JSONL do `codex exec --json` (formato verificado com codex-cli 0.169.0). */
function normalizeCodex(o: Record<string, unknown>, runId: number): Omit<AgentEvent, "at">[] {
const item = (o.item ?? {}) as CodexItem;
switch (o.type) {
case "thread.started":
run("UPDATE agent_runs SET session_id = ? WHERE id = ?", String(o.thread_id), runId);
return [{ kind: "system", text: "sessão iniciada" }];
case "item.started":
return item.type === "command_execution" ? [{ kind: "tool", text: `$ ${truncate(stripShell(item.command ?? ""), 200)}` }] : [];
case "item.completed":
switch (item.type) {
case "agent_message":
run("UPDATE agent_runs SET result = ? WHERE id = ?", String(item.text ?? "").slice(0, 20_000), runId);
return item.text?.trim() ? [{ kind: "text", text: item.text }] : [];
case "command_execution":
return [{ kind: "tool_result", text: truncate(item.aggregated_output ?? "", 1500) || "(sem saída)", isError: (item.exit_code ?? 0) !== 0 }];
case "file_change":
return [{ kind: "tool", text: `arquivos: ${(item.changes ?? []).map((c) => `${c.kind ?? "edit"} ${String(c.path ?? "").replace(REPO_ROOT, ".")}`).join(", ")}` }];
case "mcp_tool_call":
return [{ kind: "tool", text: `MCP ${item.server ?? ""} ${item.tool ?? ""}` }];
case "web_search":
return [{ kind: "tool", text: `busca: ${item.query ?? ""}` }];
case "error":
// Avisos de configuração do usuário chegam como "error" mas não interrompem.
return [{ kind: "system", text: truncate(item.message ?? "", 300) }];
default:
return [];
}
case "turn.completed": {
const u = (o.usage ?? {}) as { input_tokens?: number; cached_input_tokens?: number; output_tokens?: number };
run("UPDATE agent_runs SET num_turns = COALESCE(num_turns, 0) + 1 WHERE id = ?", runId);
return [{ kind: "result", text: `Concluído · ${u.input_tokens ?? 0} tokens de entrada (${u.cached_input_tokens ?? 0} em cache) · ${u.output_tokens ?? 0} de saída · Codex não informa custo em US$` }];
}
case "turn.failed":
case "error": {
const message = String((o.error as { message?: string } | undefined)?.message ?? o.message ?? "falha");
run("UPDATE agent_runs SET error = ? WHERE id = ?", message.slice(0, 2000), runId);
return [{ kind: "result", text: `Terminou com erro: ${truncate(message, 300)}`, isError: true }];
}
default:
return [];
}
}
function stripShell(command: string): string {
// `"...powershell.exe" -Command '...'` → só o comando interno
const m = /-Command '([\s\S]*)'$/.exec(command);
return m ? m[1] : command;
}
function summarizeInput(input: Record<string, unknown> | undefined): string {
if (!input) return "";
const v = input.file_path ?? input.path ?? input.pattern ?? input.command ?? input.description ?? input.skill;
return v ? truncate(String(v).replace(REPO_ROOT, "."), 200) : truncate(JSON.stringify(input), 200);
}
function stringify(content: unknown): string {
if (typeof content === "string") return content;
if (Array.isArray(content)) return content.map((c) => (typeof c === "object" && c && "text" in c ? String((c as { text: unknown }).text) : "")).join("\n");
return JSON.stringify(content ?? "");
}
function truncate(s: string, n: number): string {
return s.length > n ? s.slice(0, n) + "…" : s;
}