IA: Claude, Codex e Gemini com login, chave de API e IA reserva; Configurações em subpáginas

- Configurações → IA (/settings/ai): um cartão por IA para instalar/atualizar a CLI pelo painel, ligar,
  entrar com a conta (OAuth pela própria CLI, num terminal) ou colar a chave de API, e testar.
  Chaves cifradas com a DPAPI do Windows em data/ai/vault.bin; só vão para a CLI no ambiente da chamada.
- Gemini CLI como terceiro agente do painel (stream-json, edição automática, shell só o liberado).
- IA reserva: execução que cai por indisponibilidade (cota, 429, login, chave, rede) pausa a IA e recomeça
  a mesma tarefa na próxima pronta da ordem; migração v10 (agent_runs.fallback_of).
- Configurações viraram subpáginas (IA, Publicação, Apps das redes, Navegador, Sobre os modos), também no
  menu lateral; links antigos apontam para a subpágina certa.
- Contrato com o Clipador em doc/ia.md; skill do CenaForge atualizada até a 1.51.0.

O login gratuito do Gemini CLI para conta pessoal foi encerrado pelo Google (IneligibleTierError): para
conta pessoal, use a chave do AI Studio.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-18 01:51:12 -03:00
co-authored by Claude Opus 5.5
parent 0567c7454a
commit ed31d52df0
40 changed files with 1900 additions and 186 deletions
+127
View File
@@ -0,0 +1,127 @@
// IA: configuração (data/ai/settings.json), classificador de indisponibilidade, ambiente por modo de login, cofre
// DPAPI (só no Windows) e o normalizador do Gemini. Tudo numa pasta TEMPORÁRIA (CENAFORGE_ROOT); nenhuma CLI real é
// chamada. Rodar: pnpm --filter cenaforge-panel test:panel
import assert from "node:assert/strict";
import fs from "node:fs";
import os from "node:os";
import path from "node:path";
import { before, describe, it } from "node:test";
const ROOT = fs.mkdtempSync(path.join(os.tmpdir(), "cenaforge-ai-"));
process.env.CENAFORGE_ROOT = ROOT;
type Ai = typeof import("./ai");
type Agents = typeof import("./agents");
type Db = typeof import("./db");
let ai: Ai;
let agents: Agents;
let dbm: Db;
const SETTINGS = () => path.join(ROOT, "data", "ai", "settings.json");
before(async () => {
ai = await import("./ai");
agents = await import("./agents");
dbm = await import("./db");
});
describe("configuração da IA", () => {
it("sem arquivo usa o padrão: Claude e Codex ligados na conta, Gemini desligado", () => {
const s = ai.readAiSettings();
assert.deepEqual(s.order, ["claude", "codex", "gemini"]);
assert.equal(s.providers.claude.enabled, true);
assert.equal(s.providers.gemini.enabled, false);
assert.equal(s.providers.gemini.authMode, "apiKey");
assert.equal(s.fallback.enabled, true);
});
it("normaliza arquivo estragado: ordem sem repetição e completa, pausa dentro do limite", () => {
fs.mkdirSync(path.dirname(SETTINGS()), { recursive: true });
fs.writeFileSync(SETTINGS(), JSON.stringify({ order: ["gemini", "gemini", "x"], providers: { codex: { enabled: "sim", authMode: "nada" } }, fallback: { cooldownMin: 9999 } }));
const s = ai.readAiSettings();
assert.deepEqual(s.order, ["gemini", "claude", "codex"]);
assert.equal(s.providers.codex.enabled, true);
assert.equal(s.providers.codex.authMode, "oauth");
assert.equal(s.fallback.cooldownMin, 240);
fs.rmSync(SETTINGS());
});
it("salva só o que veio e recusa ordem inválida", () => {
const s = ai.updateAiSettings({ providers: { gemini: { enabled: true } }, order: ["codex", "gemini", "claude"], fallback: { cooldownMin: 30 } });
assert.equal(s.providers.gemini.enabled, true);
assert.deepEqual(JSON.parse(fs.readFileSync(SETTINGS(), "utf8")).order, ["codex", "gemini", "claude"]);
assert.throws(() => ai.updateAiSettings({ order: ["codex", "codex", "claude"] }), /cada IA uma vez/);
assert.throws(() => ai.updateAiSettings({ fallback: { cooldownMin: 0 } }), /entre 1 e 240/);
assert.throws(() => ai.updateAiSettings({ providers: { gemini: { authMode: "senha" as never } } }), /Modo de login/);
assert.equal(ai.readAiSettings().fallback.cooldownMin, 30);
});
});
describe("indisponibilidade (dispara a reserva)", () => {
for (const text of [
"API Error: 429 rate_limit_error", "You've hit your usage limit", "Credit balance is too low", "Overloaded (529)",
"IneligibleTierError: This client is no longer supported", "Not logged in · Please run /login", "getaddrinfo ENOTFOUND api.openai.com",
"não iniciou: spawn ENOENT", "Invalid API key",
]) it(`troca de IA: ${text}`, () => assert.equal(ai.isAvailabilityError(text), true));
for (const text of ["saiu com código 1", "SyntaxError: Unexpected token in JSON", "Parou no teto de gasto desta tarefa", ""]) {
it(`não troca: ${text || "(vazio)"}`, () => assert.equal(ai.isAvailabilityError(text), false));
}
});
describe("ambiente de cada chamada", () => {
it("modo conta tira a chave do ambiente; Gemini na conta liga GOOGLE_GENAI_USE_GCA", () => {
ai.updateAiSettings({ providers: { claude: { authMode: "oauth" }, gemini: { authMode: "oauth" } } });
const base = { ANTHROPIC_API_KEY: "sk-ant-velha", GEMINI_API_KEY: "AIza-velha", PATH: "x" };
const claude = ai.providerEnv("claude", base);
assert.equal(claude.ANTHROPIC_API_KEY, undefined);
assert.equal(claude.PATH, "x");
const gemini = ai.providerEnv("gemini", base);
assert.equal(gemini.GEMINI_API_KEY, undefined);
assert.equal(gemini.GOOGLE_GENAI_USE_GCA, "true");
});
it("modo chave sem chave salva não vaza a do ambiente do painel", () => {
ai.updateAiSettings({ providers: { codex: { authMode: "apiKey" } } });
assert.equal(ai.providerEnv("codex", { CODEX_API_KEY: "sk-do-sistema" }).CODEX_API_KEY, undefined);
});
it("cofre DPAPI: guarda, injeta só na chamada e apaga", { skip: process.platform !== "win32" && "DPAPI só existe no Windows" }, () => {
assert.throws(() => ai.setApiKey("codex", "curta"), /não parece válida/);
ai.setApiKey("codex", "sk-test-0123456789abcdefWXYZ");
const bytes = fs.readFileSync(path.join(ROOT, "data", "ai", "vault.bin"));
assert.equal(bytes.includes(Buffer.from("sk-test")), false, "a chave não pode ficar em texto claro");
assert.equal(ai.providerEnv("codex", {}).CODEX_API_KEY, "sk-test-0123456789abcdefWXYZ");
ai.setApiKey("codex", null);
assert.equal(fs.existsSync(path.join(ROOT, "data", "ai", "vault.bin")), false);
assert.equal(ai.providerEnv("codex", {}).CODEX_API_KEY, undefined);
});
});
describe("Gemini: eventos do stream-json", () => {
it("junta o texto em pedaços, registra sessão, ferramenta e resultado", () => {
const id = Number(dbm.run(`INSERT INTO agent_runs (provider, model, kind, prompt, status, log_path, started_at)
VALUES ('gemini', '', 'free', 'oi', 'running', '', ?)`, dbm.now()).lastInsertRowid);
const state: import("./agents").GeminiState = { text: "" };
const n = (o: Record<string, unknown>) => agents.normalizeGemini(o, id, state);
assert.deepEqual(n({ type: "init", session_id: "abc-123", model: "gemini-3.5-flash" }).map((e) => e.kind), ["system"]);
assert.deepEqual(n({ type: "message", role: "user", content: "oi" }), []);
assert.deepEqual(n({ type: "message", role: "assistant", content: "Vou ", delta: true }), []);
assert.deepEqual(n({ type: "message", role: "assistant", content: "ler.", delta: true }), []);
const tool = n({ type: "tool_use", tool_name: "read_file", tool_id: "t1", parameters: { file_path: "README.md" } });
assert.deepEqual(tool.map((e) => [e.kind, e.text]), [["text", "Vou ler."], ["tool", "read_file README.md"]]);
assert.equal(n({ type: "tool_result", tool_id: "t1", status: "error", error: { message: "sem permissão" } })[0].isError, true);
const done = n({ type: "result", status: "error", error: { type: "API", message: "429 quota exceeded" }, stats: {} });
assert.equal(done[0].isError, true);
const row = dbm.get<{ session_id: string; error: string; num_turns: number }>("SELECT session_id, error, num_turns FROM agent_runs WHERE id = ?", id)!;
assert.equal(row.session_id, "abc-123");
assert.match(row.error, /429/);
assert.equal(ai.isAvailabilityError(row.error), true);
});
it("argumentos: modo headless, edição automática, retomada e shell só o liberado", () => {
const args = agents.geminiArgs("faça X", "gemini-2.5-pro", "sess-1");
assert.deepEqual(args.slice(0, 7), ["-p", "faça X", "-o", "stream-json", "--approval-mode", "auto_edit", "--skip-trust"]);
assert.ok(args.includes("--resume") && args.includes("sess-1"));
assert.ok(args.some((a) => a.startsWith("run_shell_command(pnpm render")));
assert.equal(args.includes("--yolo"), false);
});
});