vibeeditor-render 0.3.2 → 0.4.0

package/cli/vibeeditor-render.js

@@ -182,6 +182,35 @@ async function versaoNova() {
   return null;
 }
 
+/**
+ * Atualização ao abrir: se saiu versão nova no npm, troca por ela na hora (npx com o número exato, então a cópia
+ * guardada do npx não segura a antiga) e esta fica só esperando a nova fechar. Não roda em desenvolvimento (com o
+ * código-fonte do host ao lado) nem duas vezes seguidas (VIBE_RENDER_ATUALIZADO), e nunca trava a abertura:
+ * sem internet ou com o npm fora, segue na versão atual.
+ */
+async function atualizarSeTiver(argv) {
+  if (process.env.VIBE_RENDER_ATUALIZADO || process.env.VIBE_RENDER_SEM_ATUALIZAR) return false;
+  if (fs.existsSync(path.join(RAIZ, "host", "build.mjs"))) return false;
+  const nova = await versaoNova();
+  if (!nova) return false;
+  dizer(`${azul("›")} Saiu a versão ${negrito(nova)} (esta é a ${VERSAO}). Atualizando e abrindo a nova…`);
+  // no Windows o npx é um .cmd e precisa do shell: argumento com espaço (--pasta "C:\Meus Vídeos") vai entre aspas
+  const args = process.platform === "win32" ? argv.map((a) => (/[\s"]/.test(a) ? `"${a.replace(/"/g, '\\"')}"` : a)) : argv;
+  const filho = spawn("npx", ["-y", `${PACOTE.name}@${nova}`, ...args], {
+    stdio: "inherit", shell: process.platform === "win32", env: {...process.env, VIBE_RENDER_ATUALIZADO: "1"},
+  });
+  // o Ctrl+C chega nos dois: quem cuida é a versão nova; esta só repassa o código de saída
+  process.on("SIGINT", () => {});
+  await new Promise((ok) => {
+    filho.on("error", (e) => {
+      dizer(`${ambar("!")} Não consegui atualizar (${e.message}). Sigo na ${VERSAO}.`);
+      ok(false);
+    });
+    filho.on("exit", (code) => process.exit(code == null ? 0 : code));
+  });
+  return false;
+}
+
 /** "1.10.0" é mais nova que "1.9.3"? (só números; pré-lançamentos não entram) */
 function maisNova(a, b) {
   const x = String(a).split(".").map(Number), y = String(b).split(".").map(Number);
@@ -255,7 +284,8 @@ async function principal() {
   }
 
   dizer(`\n${negrito(azul("▶ Vibe Render"))} ${cinza(`v${VERSAO}`)}  ${cinza("· exporta os vídeos do Editor IA neste computador")}\n`);
-  versaoNova().then((v) => v && dizer(`${ambar("!")} Saiu a versão ${v}. Feche e abra de novo com ${azul("npx vibeeditor-render@latest")}.`));
+  // versão nova no npm: abre direto nela (esta só espera); sem internet, segue nesta
+  await atualizarSeTiver(process.argv.slice(2));
 
   const {PORTAS} = require("../core/config");
   const outra = await jaAberto(PORTAS);

package/core/ia.js

@@ -0,0 +1,375 @@
+// Motor de IA "Claude Code" do Editor IA: em vez de o site pagar a API por token, o Vibe Render roda o Claude Code
+// instalado neste computador (`claude -p`, binário original da Anthropic), logado na assinatura da própria pessoa
+// (Pro/Max): o gasto sai do limite do plano dela. Nada de login passa por aqui: o Claude Code usa o login que a
+// pessoa fez nele, e o Vibe Render tira ANTHROPIC_API_KEY do ambiente para não cair na cobrança da API.
+//
+// As ferramentas continuam no site (os projetos moram no navegador, no OPFS): o Vibe Render expõe um servidor MCP
+// local por conversa com as definições que o site mandou; cada chamada vira um evento "chamada" para o site, que
+// roda a ferramenta e devolve o resultado (POST .../resultado). A pesquisa na internet usa o WebSearch/WebFetch
+// do próprio Claude Code. Rotas (sessão do site conferida pelo servidor):
+//   GET  /v1/ia/status                           {instalado, versao, logado, plano, email, erro}
+//   POST /v1/ia/conversas                        {sistema, mensagem, ferramentas, modelo, esforco, web, sessao?} → {id}
+//   GET  /v1/ia/conversas/<id>/eventos?desde=N   eventos a partir do N (espera até ~25 s por novidade)
+//   POST /v1/ia/conversas/<id>/resultado         {chamada, conteudo, erro}
+//   POST /v1/ia/conversas/<id>/cancelar
+//   POST /v1/ia/mcp/<id>                         o servidor MCP (só o processo do claude, com o token da conversa)
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const crypto = require("node:crypto");
+const {spawn, execFile} = require("node:child_process");
+
+const MAX_SIMULTANEAS = 3;
+const ESPERA_EVENTOS = 25000;
+const GUARDA_DEPOIS_DO_FIM = 10 * 60000; // o site pode reconectar e ler o fim depois
+const PREFIXO_MCP = "mcp__vibe__";
+const MODELOS = new Set(["claude-opus-5-5", "claude-sonnet-5-5", "claude-haiku-5-5", "claude-fable-5-1"]);
+const ESFORCOS = new Set(["low", "medium", "high", "xhigh", "max"]);
+const WEB = ["WebSearch", "WebFetch"];
+
+const erro = (status, mensagem) => Object.assign(new Error(mensagem), {status});
+
+/** onde está o executável do Claude Code (o .cmd do npm só chama o .exe: chamamos direto, sem shell) */
+function acharClaude(env = process.env, plataforma = process.platform, casa = os.homedir()) {
+  const existe = (p) => {
+    try {
+      return fs.statSync(p).isFile();
+    } catch {
+      return false;
+    }
+  };
+  if (env.VIBE_RENDER_CLAUDE && existe(env.VIBE_RENDER_CLAUDE)) return env.VIBE_RENDER_CLAUDE;
+  const pastas = String(env.PATH || env.Path || "").split(path.delimiter).filter(Boolean);
+  if (plataforma === "win32") {
+    pastas.push(path.join(casa, ".local", "bin"));
+    for (const d of pastas) {
+      const exe = path.join(d, "claude.exe");
+      if (existe(exe)) return exe;
+      const cmd = path.join(d, "claude.cmd");
+      if (existe(cmd)) {
+        const m = /"%dp0%\\([^"]+\.exe)"/i.exec(fs.readFileSync(cmd, "utf8"));
+        if (m && existe(path.join(d, m[1]))) return path.join(d, m[1]);
+      }
+    }
+    return null;
+  }
+  pastas.push(path.join(casa, ".local", "bin"), path.join(casa, ".claude", "local"));
+  for (const d of pastas) if (existe(path.join(d, "claude"))) return path.join(d, "claude");
+  return null;
+}
+
+/** ambiente do claude: sem chave de API (senão cobra a API em vez da assinatura) e sem o contexto do computador */
+function ambiente(env = process.env) {
+  const e = {...env};
+  delete e.ANTHROPIC_API_KEY;
+  delete e.ANTHROPIC_AUTH_TOKEN;
+  delete e.CLAUDECODE; // se o Vibe Render subiu de dentro de um Claude Code, o filho não pode achar que é aninhado
+  e.CLAUDE_CODE_DISABLE_CLAUDE_MDS = "1";
+  e.CLAUDE_CODE_DISABLE_AUTO_MEMORY = "1";
+  e.MCP_TOOL_TIMEOUT = String(2 * 60 * 60000); // preparar/render de vídeo longo roda no site e pode demorar
+  e.MCP_TIMEOUT = "30000";
+  return e;
+}
+
+/** argumentos do claude -p para uma volta da conversa */
+function argumentos({modelo, esforco, web, sessao, arqSistema, arqMcp}) {
+  const a = ["-p", "--output-format", "stream-json", "--verbose", "--include-partial-messages", "--input-format", "stream-json",
+    "--model", modelo, "--effort", esforco, "--system-prompt-file", arqSistema,
+    "--mcp-config", arqMcp, "--strict-mcp-config", "--setting-sources", "", "--disable-slash-commands",
+    "--permission-mode", "dontAsk", "--allowedTools", "mcp__vibe", ...(web ? WEB : []),
+    "--tools", ...(web ? WEB : [""])];
+  if (sessao) a.push("--resume", sessao);
+  return a;
+}
+
+/** blocos da Messages API (o que as ferramentas do site devolvem) → conteúdo do MCP */
+function paraMcp(conteudo) {
+  if (conteudo == null || conteudo === "") return [{type: "text", text: "ok"}];
+  if (typeof conteudo === "string") return [{type: "text", text: conteudo}];
+  const blocos = Array.isArray(conteudo) ? conteudo : [conteudo];
+  return blocos.map((b) => {
+    if (b && b.type === "image" && b.source && b.source.type === "base64") return {type: "image", data: b.source.data, mimeType: b.source.media_type};
+    if (b && b.type === "text") return {type: "text", text: String(b.text || "")};
+    return {type: "text", text: typeof b === "string" ? b : JSON.stringify(b)};
+  });
+}
+
+/** valida o pedido do site; o system prompt e as ferramentas vêm do site, mas os limites são daqui */
+function validarConversa(d) {
+  if (!d || typeof d !== "object") throw erro(400, "corpo inválido");
+  if (typeof d.sistema !== "string" || !d.sistema.trim()) throw erro(400, "sistema: texto obrigatório");
+  if (!d.mensagem || typeof d.mensagem !== "object" || !Array.isArray(d.mensagem.content)) throw erro(400, "mensagem: {content: [...]}");
+  const ferramentas = Array.isArray(d.ferramentas) ? d.ferramentas : [];
+  if (ferramentas.length > 80) throw erro(400, "ferramentas demais");
+  for (const f of ferramentas) {
+    if (!f || !/^[a-z0-9_]{1,60}$/.test(String(f.name || ""))) throw erro(400, `nome de ferramenta inválido: ${f && f.name}`);
+  }
+  const modelo = MODELOS.has(d.modelo) ? d.modelo : "claude-opus-5-5";
+  const esforco = ESFORCOS.has(d.esforco) ? d.esforco : "high";
+  const sessao = d.sessao == null ? null : String(d.sessao);
+  if (sessao && !/^[0-9a-f-]{36}$/i.test(sessao)) throw erro(400, "sessao inválida");
+  return {sistema: d.sistema, mensagem: {role: "user", content: d.mensagem.content}, ferramentas, modelo, esforco, web: d.web === true, sessao};
+}
+
+/** texto do erro que o claude devolveu, em português quando é o limite da assinatura */
+function erroDoClaude(texto) {
+  const t = String(texto || "").trim();
+  if (/usage limit|limit reached|rate.?limit|5-hour|weekly limit|out of extra usage/i.test(t)) {
+    return `O limite da sua assinatura do Claude acabou por agora (${t.slice(0, 200)}). Espere renovar ou troque o motor para API em Configurações → Claude.`;
+  }
+  if (/not logged in|please run \/login|invalid api key|authentication/i.test(t)) return "O Claude Code deste computador não está logado. Abra um terminal, rode `claude` e faça o login com a sua conta.";
+  return t.slice(0, 1500) || "O Claude Code parou sem dizer o motivo.";
+}
+
+/** encerra o processo e os filhos (no Windows o kill não leva a árvore junto) */
+function encerrar(p) {
+  if (!p || p.exitCode !== null) return;
+  if (process.platform === "win32") execFile("taskkill", ["/pid", String(p.pid), "/T", "/F"], {windowsHide: true}, () => {});
+  else p.kill("SIGTERM");
+}
+
+/**
+ * opc: {dirDados, porta() (do servidor, para o MCP), env, log, spawn (injetável), acharClaude (injetável), versao}
+ */
+function criarIa(opc) {
+  const env = opc.env || process.env;
+  const log = opc.log || (() => {});
+  const rodar = opc.spawn || spawn;
+  const dir = path.join(opc.dirDados, "ia");
+  const trabalho = path.join(dir, "trabalho"); // cwd fixo: o --resume procura a sessão pela pasta
+  const conversas = new Map();
+  let statusCache = null;
+
+  const bin = () => (opc.acharClaude || acharClaude)(env);
+
+  function executar(binario, args, ms = 20000) {
+    return new Promise((ok) => {
+      execFile(binario, args, {env: ambiente(env), timeout: ms, windowsHide: true}, (e, out, err) => ok({e, out: String(out || ""), err: String(err || "")}));
+    });
+  }
+
+  /** o Claude Code está instalado e logado? (cache de 30 s: a tela pergunta sempre que abre) */
+  async function status(forcar = false) {
+    if (!forcar && statusCache && Date.now() - statusCache.em < 30000) return statusCache.v;
+    const b = bin();
+    let v;
+    if (!b) v = {instalado: false, erro: "Não encontrei o Claude Code neste computador."};
+    else {
+      const [ver, auth] = await Promise.all([executar(b, ["--version"]), executar(b, ["auth", "status"])]);
+      let a = {};
+      try {
+        a = JSON.parse(auth.out);
+      } catch {
+        /* versão antiga sem JSON: fica sem os detalhes */
+      }
+      v = {instalado: true, versao: ver.out.trim().split(/\s/)[0] || null, logado: a.loggedIn === true,
+        metodo: a.authMethod || null, plano: a.subscriptionType || null, email: a.email || null};
+      if (v.logado && v.metodo !== "claude.ai") v.aviso = "O Claude Code deste computador está logado com chave de API: o gasto vai para a API, não para a assinatura.";
+    }
+    statusCache = {em: Date.now(), v};
+    return v;
+  }
+
+  function emitir(c, ev) {
+    c.eventos.push({...ev, n: c.eventos.length});
+    for (const f of c.ouvintes) f();
+    c.ouvintes.clear();
+  }
+
+  function terminar(c, fim) {
+    if (c.fim) return;
+    c.fim = fim;
+    for (const [, p] of c.pendentes) p.ok({erro: true, conteudo: "a conversa terminou"});
+    c.pendentes.clear();
+    emitir(c, {tipo: "fim", ...fim});
+    setTimeout(() => {
+      conversas.delete(c.id);
+      fs.rm(c.pasta, {recursive: true, force: true}, () => {});
+    }, GUARDA_DEPOIS_DO_FIM).unref();
+  }
+
+  /** uma linha do stream-json do claude → eventos para o site */
+  function lerLinha(c, linha) {
+    let j;
+    try {
+      j = JSON.parse(linha);
+    } catch {
+      return;
+    }
+    if (j.type === "system" && j.subtype === "init") {
+      c.sessao = j.session_id || c.sessao;
+      emitir(c, {tipo: "inicio", sessao: c.sessao, modelo: j.model});
+      return;
+    }
+    if (j.type === "stream_event" && j.event) {
+      const ev = j.event;
+      if (ev.type === "content_block_delta" && ev.delta && ev.delta.type === "text_delta") emitir(c, {tipo: "texto", delta: ev.delta.text});
+      if (ev.type === "content_block_start" && ev.content_block && ev.content_block.type === "tool_use") {
+        const nome = String(ev.content_block.name || "");
+        const nosso = nome.startsWith(PREFIXO_MCP);
+        emitir(c, {tipo: "ferramenta", nome: nosso ? nome.slice(PREFIXO_MCP.length) : nome, id: ev.content_block.id, servidor: !nosso});
+      }
+      return;
+    }
+    if (j.type === "assistant" && j.message) {
+      for (const b of j.message.content || []) {
+        if (b.type === "tool_use" && WEB.includes(b.name)) c.web.set(b.id, b);
+        if (b.type === "text" && b.text) c.ultimoTexto = b.text;
+      }
+      if (j.message.usage) emitir(c, {tipo: "uso", uso: j.message.usage, modelo: j.message.model});
+      return;
+    }
+    if (j.type === "user" && j.message && Array.isArray(j.message.content)) {
+      for (const b of j.message.content) {
+        const pedido = b.type === "tool_result" && c.web.get(b.tool_use_id);
+        if (!pedido) continue;
+        const alvo = String((pedido.input && (pedido.input.query || pedido.input.url)) || "").slice(0, 160);
+        const nome = pedido.name === "WebSearch" ? "web_search" : "web_fetch";
+        emitir(c, {tipo: "ferramenta_fim", nome, id: pedido.id, entrada: pedido.input, alvo, servidor: true, erro: !!b.is_error, resumo: b.is_error ? "erro" : (nome === "web_search" ? "resultados" : "página lida")});
+      }
+      return;
+    }
+    if (j.type === "result") {
+      c.resultado = j;
+    }
+  }
+
+  async function criar(corpo) {
+    const d = validarConversa(corpo);
+    const ativas = [...conversas.values()].filter((c) => !c.fim).length;
+    if (ativas >= MAX_SIMULTANEAS) throw erro(429, `Já há ${ativas} execuções da IA neste computador. Espere uma terminar.`);
+    const b = bin();
+    if (!b) throw erro(409, "Não encontrei o Claude Code neste computador. Instale (code.claude.com) e faça o login com a sua conta.");
+
+    const id = crypto.randomUUID();
+    const token = crypto.randomBytes(24).toString("hex");
+    const pasta = path.join(dir, "conversas", id);
+    fs.mkdirSync(pasta, {recursive: true});
+    fs.mkdirSync(trabalho, {recursive: true});
+    const arqSistema = path.join(pasta, "sistema.md");
+    const arqMcp = path.join(pasta, "mcp.json");
+    fs.writeFileSync(arqSistema, d.sistema);
+    fs.writeFileSync(arqMcp, JSON.stringify({mcpServers: {vibe: {type: "http", url: `http://127.0.0.1:${opc.porta()}/v1/ia/mcp/${id}`, headers: {Authorization: `Bearer ${token}`}}}}));
+
+    const c = {id, token, pasta, ferramentas: d.ferramentas, eventos: [], ouvintes: new Set(), pendentes: new Map(), web: new Map(),
+      sessao: d.sessao, ultimoTexto: "", resultado: null, fim: null, proc: null, saidaErro: ""};
+    conversas.set(id, c);
+
+    const p = rodar(b, argumentos({...d, arqSistema, arqMcp}), {cwd: trabalho, env: ambiente(env), windowsHide: true, stdio: ["pipe", "pipe", "pipe"]});
+    c.proc = p;
+    let resto = "";
+    p.stdout.on("data", (buf) => {
+      resto += buf.toString("utf8");
+      const linhas = resto.split("\n");
+      resto = linhas.pop();
+      for (const l of linhas) if (l.trim()) lerLinha(c, l);
+    });
+    p.stderr.on("data", (buf) => {
+      c.saidaErro = (c.saidaErro + buf.toString("utf8")).slice(-4000);
+    });
+    p.on("error", (e) => terminar(c, {motivo: "erro", erro: `Não consegui abrir o Claude Code: ${e.message}`}));
+    p.on("close", (code) => {
+      if (resto.trim()) lerLinha(c, resto);
+      const r = c.resultado;
+      if (c.cancelado) return terminar(c, {motivo: "parado", sessao: c.sessao});
+      if (r && !r.is_error && r.subtype === "success") {
+        return terminar(c, {motivo: "fim", sessao: r.session_id || c.sessao, texto: String(r.result || c.ultimoTexto || ""), custo: r.total_cost_usd, uso: r.usage, voltas: r.num_turns});
+      }
+      if (r && r.subtype === "error_max_turns") return terminar(c, {motivo: "limite", sessao: c.sessao});
+      const texto = (r && (r.result || (r.errors || []).join(" "))) || c.saidaErro || `saiu com código ${code}`;
+      log("ia", `claude terminou com erro: ${String(texto).slice(0, 300)}`);
+      terminar(c, {motivo: "erro", sessao: c.sessao, erro: erroDoClaude(texto)});
+    });
+    // a mensagem da pessoa vai pelo stdin (stream-json aceita imagens e texto longo sem passar pela linha de comando)
+    p.stdin.on("error", () => {});
+    p.stdin.end(`${JSON.stringify({type: "user", message: d.mensagem})}\n`);
+    log("ia", `conversa ${id.slice(0, 8)} · ${d.modelo} · ${d.ferramentas.length} ferramentas${d.sessao ? " · continuando" : ""}`);
+    return {id};
+  }
+
+  /** eventos a partir de `desde`; se ainda não há nada novo, espera até ESPERA_EVENTOS */
+  function eventos(id, desde, sinal) {
+    const c = conversas.get(id);
+    if (!c) return Promise.resolve(null);
+    const pegar = () => ({eventos: c.eventos.slice(desde), fim: !!c.fim});
+    if (c.eventos.length > desde || c.fim) return Promise.resolve(pegar());
+    return new Promise((ok) => {
+      const pronto = () => {
+        clearTimeout(t);
+        ok(pegar());
+      };
+      const t = setTimeout(() => {
+        c.ouvintes.delete(pronto);
+        ok(pegar());
+      }, ESPERA_EVENTOS);
+      c.ouvintes.add(pronto);
+      if (sinal) sinal.once("close", () => {
+        clearTimeout(t); c.ouvintes.delete(pronto);
+      });
+    });
+  }
+
+  function resultado(id, corpo) {
+    const c = conversas.get(id);
+    if (!c) throw erro(404, "conversa não encontrada");
+    const p = c.pendentes.get(String(corpo && corpo.chamada));
+    if (!p) throw erro(404, "chamada não encontrada (já respondida ou a conversa terminou)");
+    c.pendentes.delete(String(corpo.chamada));
+    p.ok({erro: corpo.erro === true, conteudo: corpo.conteudo});
+    return {ok: true};
+  }
+
+  function cancelar(id) {
+    const c = conversas.get(id);
+    if (!c) throw erro(404, "conversa não encontrada");
+    if (!c.fim) {
+      c.cancelado = true;
+      encerrar(c.proc);
+    }
+    return {ok: true};
+  }
+
+  /** o servidor MCP da conversa (JSON-RPC por HTTP, respostas em JSON) */
+  async function mcp(id, autorizacao, mensagem) {
+    const c = conversas.get(id);
+    const tk = String(autorizacao || "").replace(/^Bearer\s+/i, "");
+    if (!c || !tk || tk.length !== c.token.length || !crypto.timingSafeEqual(Buffer.from(tk), Buffer.from(c.token))) throw erro(401, "token");
+    if (Array.isArray(mensagem)) return (await Promise.all(mensagem.map((m) => responder(c, m)))).filter(Boolean);
+    return responder(c, mensagem);
+  }
+
+  async function responder(c, m) {
+    if (!m || typeof m !== "object") return {jsonrpc: "2.0", id: null, error: {code: -32600, message: "pedido inválido"}};
+    if (m.id === undefined || m.id === null) return null; // notificação: nada a responder
+    const ok = (result) => ({jsonrpc: "2.0", id: m.id, result});
+    const p = m.params || {};
+    if (m.method === "initialize") {
+      return ok({protocolVersion: p.protocolVersion || "2025-06-18", capabilities: {tools: {}}, serverInfo: {name: "vibe", version: opc.versao || "0"}});
+    }
+    if (m.method === "ping") return ok({});
+    if (m.method === "tools/list") {
+      return ok({tools: c.ferramentas.map((f) => ({name: f.name, description: f.description || "", inputSchema: f.input_schema || {type: "object"}}))});
+    }
+    if (m.method === "tools/call") {
+      if (c.fim) return ok({content: [{type: "text", text: "a conversa terminou"}], isError: true});
+      const chamada = crypto.randomUUID();
+      const r = await new Promise((resolver) => {
+        c.pendentes.set(chamada, {ok: resolver});
+        emitir(c, {tipo: "chamada", chamada, nome: String(p.name || ""), entrada: p.arguments || {}});
+      });
+      return ok({content: paraMcp(r.conteudo), isError: !!r.erro});
+    }
+    return {jsonrpc: "2.0", id: m.id, error: {code: -32601, message: `método desconhecido: ${m.method}`}};
+  }
+
+  function cancelarTodas() {
+    for (const c of conversas.values()) if (!c.fim) {
+      c.cancelado = true;
+      encerrar(c.proc);
+    }
+  }
+
+  return {status, criar, eventos, resultado, cancelar, mcp, cancelarTodas, _conversas: conversas};
+}
+
+module.exports = {criarIa, acharClaude, argumentos, paraMcp, validarConversa, erroDoClaude, ambiente};

package/core/jobs.js

@@ -45,7 +45,9 @@ const NOMES_NORMALIZAVEIS = ["original"];
 /** quantas vezes um job tenta renderizar quando a falha é passageira (do compositor, não do código do vídeo) */
 const TENTATIVAS = 2;
 /** erros do compositor do Remotion que não dependem do código nem dos arquivos: vale tentar de novo */
-const falhaPassageira = (e) => /No frame found at position|Compositor exited|Compositor quit|Request closed/i.test(String((e && e.message) || e));
+// delayRender/timeout: quadro que demorou a carregar (vídeo-base pesado, máquina ocupada) — repete com 1 aba, como o
+// hv render do editor local (ee515e1)
+const falhaPassageira = (e) => /No frame found at position|Compositor exited|Compositor quit|Request closed|delayRender|timed out|timeout/i.test(String((e && e.message) || e));
 
 /** valida o corpo do POST /v1/jobs; devolve a especificação limpa ou lança {status, message} */
 function validarJob(d, cache) {
@@ -223,12 +225,14 @@ function criarJobs(opc) {
       ffmpeg = await normalizarOriginais(j, ffmpeg, cancel);
       const ativos = Object.fromEntries(Object.entries(j.arquivos).map(([nome, sha]) => [nome, opc.urlAtivo(j.id, sha, j.token)]));
       const inputProps = {codigo: j.codigo, props: j.props, ativos, composicao: j.composicao};
-      const comum = {browserExecutable: opc.navegador || null, binariesDirectory: opc.binarios || null, chromeMode: "headless-shell", logLevel: "warn"};
+      // 3D (three.js / kit Motion explicativo) precisa de WebGL de verdade: "angle" usa a placa de vídeo pelo ANGLE
+      const gl = usaWebGL(j.codigo) ? "angle" : null;
+      const comum = {browserExecutable: opc.navegador || null, binariesDirectory: opc.binarios || null, chromeMode: "headless-shell", logLevel: "warn", ...(gl ? {chromiumOptions: {gl}} : {})};
       const p = PRESETS[j.preset];
       fs.mkdirSync(opc.dirTmp, {recursive: true});
       for (let tentativa = 1; ; tentativa++) {
         try {
-          browser = await R.openBrowser("chrome", {browserExecutable: comum.browserExecutable, chromeMode: "headless-shell", logLevel: "warn"});
+          browser = await R.openBrowser("chrome", {browserExecutable: comum.browserExecutable, chromeMode: "headless-shell", logLevel: "warn", ...(gl ? {chromiumOptions: {gl}} : {})});
           const composition = await R.selectComposition({...comum, serveUrl: opc.hostDir, id: "VibeHost", inputProps, puppeteerInstance: browser});
           mudar(j, {status: "renderizando", etapa: "Renderizando quadros"});
           // na repetição vai com 1 aba: vídeo com GOP longo / fps variável (ex.: WhatsApp, 1 quadro-chave a cada 10 s)
@@ -307,4 +311,10 @@ function criarJobs(opc) {
   return {criar, obter, interno, cancelar, ouvir, ativos, emUso: () => new Set([...jobs.values()].filter((j) => j.status !== "pronto").flatMap((j) => [...Object.values(j.arquivos || {}), ...Object.values(j.originais || {})]))};
 }
 
-module.exports = {criarJobs, validarJob, escalaDo, concorrencia, nomeSaida, falhaPassageira, TENTATIVAS, NOMES_NORMALIZAVEIS};
+/** o código usa 3D (kit Motion explicativo, three.js)? Então o render precisa de WebGL de verdade (gl "angle") */
+function usaWebGL(codigo) {
+  const c = String(codigo || "");
+  return ["@vibe/explicativo", "@remotion/three", "@react-three/fiber", 'require("three")', "require('three')"].some((m) => c.includes(m));
+}
+
+module.exports = {criarJobs, validarJob, escalaDo, concorrencia, nomeSaida, falhaPassageira, usaWebGL, TENTATIVAS, NOMES_NORMALIZAVEIS};

package/core/nucleo.js

@@ -7,6 +7,7 @@ const {criarPareamento} = require("./pareamento");
 const {criarServidor} = require("./servidor");
 const {criarTranscricoes} = require("./transcricao");
 const {criarVoz} = require("./voz");
+const {criarIa} = require("./ia");
 const {LIMITES, origensPermitidas, STATUS_INTERVALO} = require("./config");
 
 /**
@@ -25,7 +26,8 @@ async function criarNucleo(opc) {
   });
   const transcricoes = criarTranscricoes({cache, dirDados: opc.dirDados, dirTmp: path.join(opc.dirDados, "tmp"), whisper: opc.whisper});
   const voz = criarVoz({dirDados: opc.dirDados, env, urlInicial: opc.voiceStudio, log: opc.log});
-  servidor = criarServidor({versao: opc.versao, origens: origensPermitidas(env), cache, jobs, transcricoes, voz, pareamento, mostrarArquivo: opc.mostrarArquivo, log: opc.log});
+  const ia = criarIa({dirDados: opc.dirDados, env, versao: opc.versao, porta: () => servidor.porta(), log: opc.log});
+  servidor = criarServidor({versao: opc.versao, origens: origensPermitidas(env), cache, jobs, transcricoes, voz, ia, pareamento, mostrarArquivo: opc.mostrarArquivo, log: opc.log});
   const porta = await servidor.iniciar(opc.portas);
   pareamento.conferir();
   voz.aoIniciar(); // abre o VoiceStudio junto, se a pessoa pediu (Configurações → VoiceStudio)
@@ -37,6 +39,7 @@ async function criarNucleo(opc) {
       clearInterval(relogio);
       for (const j of jobs.ativos()) jobs.cancelar(j.id);
       transcricoes.cancelarTodas();
+      ia.cancelarTodas();
       await servidor.parar();
     },
   };

package/core/servidor.js

@@ -99,6 +99,24 @@ function criarServidor(opc) {
       return enviarArquivo(req, res, opc.cache.caminho(sha), {"Access-Control-Allow-Origin": "*", "Cache-Control": "no-store"});
     }
 
+    // servidor MCP da conversa de IA: quem chama é o processo do claude deste computador (sem Origin), com o token
+    // aleatório da conversa; nenhum navegador tem esse token (core/ia.js)
+    if (partes[0] === "v1" && partes[1] === "ia" && partes[2] === "mcp" && partes.length === 4 && opc.ia) {
+      if (req.headers.origin) return json(403, {erro: "origem não permitida"});
+      if (req.method !== "POST") {
+        res.writeHead(405, {Allow: "POST"}); return res.end();
+      }
+      try {
+        const r = await opc.ia.mcp(partes[3], req.headers.authorization, await lerJson(req, LIMITES.jsonBytes));
+        if (r === null || (Array.isArray(r) && !r.length)) {
+          res.writeHead(202); return res.end();
+        }
+        return json(200, r);
+      } catch (e) {
+        return json(e.status || 500, {erro: e.status ? e.message : "erro interno"});
+      }
+    }
+
     const origin = req.headers.origin;
     if (!origemPermitida(origin, opc.origens)) return json(403, {erro: "origem não permitida"});
     const cors = {
@@ -116,7 +134,7 @@ function criarServidor(opc) {
       const p = opc.pareamento.visao();
       return json(200, {app: "vibe-render", versao: opc.versao, pareado: p.pareado, dispositivoId: p.dispositivoId, email: p.email,
         plataforma: process.platform, porta, acessoPlataforma: p.plataforma,
-        recursos: [...(opc.transcricoes ? ["transcricao"] : []), ...(opc.voz ? ["voz", "voz-abrir"] : [])]}, cors);
+        recursos: [...(opc.transcricoes ? ["transcricao"] : []), ...(opc.voz ? ["voz", "voz-abrir"] : []), ...(opc.ia ? ["ia"] : [])]}, cors);
     }
 
     // daqui para baixo: sessão válida deste aparelho
@@ -161,6 +179,21 @@ function criarServidor(opc) {
         if (!opc.pareamento.visao().plataforma) return json(403, {erro: "Sua conta está sem a Plataforma."}, cors);
         if (await opc.voz.rota(req, res, partes.slice(2), {json, cors})) return;
       }
+      // motor de IA "Claude Code" (assinatura da pessoa): core/ia.js
+      if (partes[0] === "v1" && partes[1] === "ia" && opc.ia) {
+        if (!opc.pareamento.visao().plataforma) return json(403, {erro: "Sua conta está sem a Plataforma."}, cors);
+        if (partes[2] === "status" && partes.length === 3 && req.method === "GET") return json(200, await opc.ia.status(u.searchParams.get("forcar") === "1"), cors);
+        if (partes[2] === "conversas" && partes.length === 3 && req.method === "POST") return json(201, await opc.ia.criar(await lerJson(req, LIMITES.jsonBytes)), cors);
+        if (partes[2] === "conversas" && partes[3] && partes.length === 5) {
+          const id = partes[3];
+          if (partes[4] === "eventos" && req.method === "GET") {
+            const r = await opc.ia.eventos(id, Math.max(0, Number(u.searchParams.get("desde")) || 0), req);
+            return r ? json(200, r, cors) : json(404, {erro: "conversa não encontrada"}, cors);
+          }
+          if (partes[4] === "resultado" && req.method === "POST") return json(200, opc.ia.resultado(id, await lerJson(req, LIMITES.jsonBytes)), cors);
+          if (partes[4] === "cancelar" && req.method === "POST") return json(200, opc.ia.cancelar(id), cors);
+        }
+      }
       if (partes[0] === "v1" && partes[1] === "jobs" && partes[2]) {
         const id = partes[2];
         const j = opc.jobs.obter(id);