primocode 8.10.5 → 8.11.1

package/bin/primocode.js

@@ -531,6 +531,13 @@ async function sendPrompt(userText) {
     }
 
     if (modo === 'primocode') {
+        // "baixa o vídeo" / "exporta em mp4" não precisa de IA NENHUMA: é
+        // abrir a última criação do Studio com #gravar — o navegador pede a
+        // permissão de tela (a aprovação), grava a passada e baixa no fim.
+        // Antes isso virava uma tarefa inteira de modelo (id inventado,
+        // mídia inventada, limite estourado) para chegar no mesmo lugar.
+        if (await baixarCriacaoDireto(userText)) { refreshPrompt(); return; }
+
         const plan = prepararPasta(userText);
 
         // Antes de gastar com a tarefa, dobra no resumo o que já passou. A
@@ -632,6 +639,30 @@ async function sendPrompt(userText) {
 const RE_DESCOBRIR = /\b(pesquis|busca|procur|descubr|investig|analis|leia|estud|olh[ae] (o site|a p[áa]gina)|ver o que)\w*/i;
 const RE_CRIAR_DEPOIS = /\b(cri[ae]|faz|faça|mont[ae]|ger[ae]|escrev[ae]|produz|desenvolv)\w*/i;
 
+/** "baixa/exporta o vídeo" resolvido na hora, sem gastar modelo. */
+const RE_BAIXAR = /\b(baixa\w*|exporta\w*|download|salva\w*)\b/i;
+const RE_PECA_STUDIO = /\b(v[ií]deo|mp4|mp3|apresenta[çc][ãa]o|slides?|reels?)\b/i;
+
+async function baixarCriacaoDireto(texto) {
+    if (!(RE_BAIXAR.test(texto) && RE_PECA_STUDIO.test(texto))) return false;
+    try {
+        const studio = require('../lib/studio');
+        const r = await studio.listar();
+        const lista = (r && r.arquivos) || [];
+        // a criação mais nova que é vídeo; sem vídeo, a mais nova de todas
+        const alvo = lista.find((a) => a.ferramenta === 'corte') || lista[0];
+        if (!alvo) return false;
+        const url = `http://localhost:7777/v/${alvo.id}#gravar`;
+        await tools.execute('open_in_browser', { target: url }, { projectDir: state.workDir || os.homedir() });
+        console.log(c.ok(`  ⎿ abrindo "${alvo.titulo}" para gravar`));
+        console.log(c.muted('    O navegador vai pedir permissão de tela — aceite (marque "compartilhar áudio da aba"'));
+        console.log(c.muted('    para levar a narração junto). O vídeo roda sozinho e baixa no fim.'));
+        return true;
+    } catch {
+        return false;   // Studio fora do ar ou sem criações: segue o caminho normal
+    }
+}
+
 async function dividirTarefa(pedido) {
     const inteiro = [{ titulo: 'tarefa', pedido }];
     if (!pedido || pedido.trim().length < 12) return inteiro;

package/lib/act.js

@@ -295,9 +295,11 @@ function encolherParaContinuar(messages) {
 
 /** Quanto esperar quando o minuto estourou. O provedor costuma dizer
  * ("Please try again in 7.664s"); sem isso, meio minuto é seguro. */
-function esperaDoErro(e) {
+function esperaDoErro(e, tentativa = 0) {
     const m = /try again in ([0-9.]+)s/i.exec(String((e && e.message) || e || ''));
-    const s = m ? Math.ceil(parseFloat(m[1])) + 2 : 30;
+    // Sem o tempo do provedor, cresce a passada a cada tentativa: bater na
+    // mesma porta a cada 30s por horas só esquenta o rate limit.
+    const s = m ? Math.ceil(parseFloat(m[1])) + 2 : Math.min(70, 30 + tentativa * 10);
     return Math.min(70, Math.max(5, s)) * 1000;
 }
 
@@ -381,7 +383,12 @@ async function runAct(userPrompt, opts) {
     // isso (num caso real "encolheu" de 2 para 2 mensagens); esperar a janela
     // virar, sim.
     let esperas = 0;
-    const MAX_ESPERAS = 3;
+    // Ordem do dono: limite de token NUNCA mais encerra a tarefa. Ele espera
+    // o quanto precisar — Esc Esc continua sendo a saída na mão do usuário.
+    // 200 esperas de até 70s são horas: na prática, para quem não apertou
+    // Esc, é "espera até dar".
+    // O teste derruba para 2 via env; em produção são 200.
+    const MAX_ESPERAS = Number(process.env.PRIMOCODE_MAX_ESPERAS || 200);
 
     let voltas = 0;
     for (let iteration = 0; iteration < MAX_ITERATIONS && !PARAR; iteration++) {
@@ -424,7 +431,7 @@ async function runAct(userPrompt, opts) {
                 }
                 if (esperas < MAX_ESPERAS) {
                     esperas++;
-                    const ms = esperaDoErro(e);
+                    const ms = esperaDoErro(e, esperas);
                     if (!subagent) {
                         const sp2 = new Spinner(`limite do minuto — continuando em ${Math.round(ms / 1000)}s`).start();
                         await new Promise((r) => setTimeout(r, ms));
@@ -451,7 +458,7 @@ async function runAct(userPrompt, opts) {
         // adjust your prompt.") caía na tela de quem não tem prompt nenhum
         // para ajustar.
         if (streamError && /failed to call a function|failed_generation|tool_use_failed/i.test(String(streamError))
-            && funcoesQuebradas < 2 && !PARAR) {
+            && funcoesQuebradas < 4 && !PARAR) {
             funcoesQuebradas++;
             if (!subagent) console.log(ident(profundidade) + c.dim('  ⎿ o modelo tropeçou na chamada — tentando de novo'));
             iteration--;
@@ -474,7 +481,7 @@ async function runAct(userPrompt, opts) {
             // anteriores gastaram a cota. Espera a janela virar e repete.
             if (esperas < MAX_ESPERAS) {
                 esperas++;
-                const ms = esperaDoErro(streamError);
+                const ms = esperaDoErro(streamError, esperas);
                 if (!subagent) {
                     const sp2 = new Spinner(`limite do minuto — continuando em ${Math.round(ms / 1000)}s`).start();
                     await new Promise((r) => setTimeout(r, ms));

package/lib/claude-engine.js

@@ -51,12 +51,35 @@ function extrairDecisao(texto) {
     return null;
 }
 
+/** JSON com quebra de linha CRUA dentro das aspas — o jeito mais comum de o
+ * motor falhar. O Claude escreve o content de um write_file com linhas de
+ * verdade em vez de \n, o JSON.parse recusa, e o turno inteiro morria com
+ * "decisão que não consegui ler". O conserto é mecânico: dentro de string,
+ * controle vira escape. */
+function consertarControles(s) {
+    let saida = '';
+    let dentro = false, escapa = false;
+    for (const c of String(s || '')) {
+        if (dentro && !escapa && (c === '\n' || c === '\r' || c === '\t')) {
+            saida += c === '\n' ? '\\n' : c === '\r' ? '\\r' : '\\t';
+            continue;
+        }
+        if (escapa) { escapa = false; saida += c; continue; }
+        if (c === '\\') { escapa = true; saida += c; continue; }
+        if (c === '"') dentro = !dentro;
+        saida += c;
+    }
+    return saida;
+}
+
 /** O JSON do bloco, tolerando o que o modelo costuma acrescentar sem querer. */
 function lerJSON(bruto) {
     let s = String(bruto || '').trim();
     // Cerca de markdown em volta do JSON — o modelo põe por hábito.
     s = s.replace(/^```(?:json)?\s*/i, '').replace(/```\s*$/, '').trim();
     try { return JSON.parse(s); } catch {}
+    try { return JSON.parse(consertarControles(s)); } catch {}
+    s = consertarControles(s);
     // Sobrou texto depois do objeto? Corta no fecha-chaves que casa com o primeiro.
     const abre = s.indexOf('{');
     if (abre === -1) return null;
@@ -69,7 +92,9 @@ function lerJSON(bruto) {
         if (dentro) continue;
         if (c === '{') nivel++;
         else if (c === '}' && --nivel === 0) {
-            try { return JSON.parse(s.slice(abre, k + 1)); } catch { return null; }
+            const trecho = s.slice(abre, k + 1);
+            try { return JSON.parse(trecho); } catch {}
+            try { return JSON.parse(consertarControles(trecho)); } catch { return null; }
         }
     }
     return null;
@@ -268,15 +293,17 @@ function ultimaMensagem(messages) {
 function emitirDecisao(textoLido, onEvent) {
     const decisao = extrairDecisao(textoLido);
     if (!decisao) {
-        // Resposta sem bloco legível. Se ela AINDA ASSIM traz a marca do
-        // protocolo, o motor falhou: mostrar isso cru — com "tool_call" e
-        // JSON na cara do usuário — é pior do que dizer que falhou.
-        let conteudo = String(textoLido || '').trim();
-        if (conteudo.includes(MARCA_INICIO) || conteudo.includes(MARCA_FIM)) {
-            conteudo = conteudo.split(MARCA_INICIO)[0].trim()
-                || 'O motor Claude Code devolveu uma decisão que não consegui ler. Tente de novo, ou volte ao motor padrão com /claude off.';
+        const cru = String(textoLido || '').trim();
+        // Traz a marca do protocolo mas o bloco não dá para ler? O motor
+        // TENTOU chamar ferramenta e errou a sintaxe. Antes isso virava
+        // desistência na tela; agora vira o mesmo erro que o loop já sabe
+        // repetir ("Failed to call a function" dispara retry da rodada).
+        if (cru.includes(MARCA_INICIO) || cru.includes(MARCA_FIM)) {
+            onEvent({ erro: 'Failed to call a function: o motor Claude devolveu um bloco ilegível — repetindo a rodada.' });
+            return;
         }
-        onEvent({ assistant_message: { content: conteudo } });
+        // Sem marca nenhuma: é resposta em texto, e texto é resposta válida.
+        onEvent({ assistant_message: { content: cru } });
         return;
     }
     if (decisao.tool_call) {
@@ -361,16 +388,31 @@ function linhaDoHistorico(m) {
 
 async function requestActViaHeadless(payload, onEvent) {
     const historico = (payload.messages || []).map(linhaDoHistorico).join('\n\n');
-    const prompt = 'Use a skill primocode-engine para esta chamada.\n\n' + historico;
+    // O protocolo vai INTEIRO no prompt. A versão anterior dizia "use a skill
+    // primocode-engine" e confiava que o headless a carregaria — quando não
+    // carregava, o Claude respondia sem bloco nenhum e o turno morria. Prompt
+    // maior, mas o Claude Code tem contexto de sobra, e o formato SEMPRE chega.
+    // SEM o cabeçalho YAML da skill: ele começa com "---", e um prompt que
+    // começa com traço o parser de argumentos do claude lê como OPÇÃO —
+    // "error: unknown option '---'" na cara do usuário, com o protocolo
+    // inteiro despejado no terminal. Foi exatamente o que aconteceu.
+    const corpoBootstrap = textoBootstrap().replace(/^---[\s\S]*?---\s*/, '');
+    const prompt = corpoBootstrap
+        + '\n\nIMPORTANTE: no JSON do bloco, escreva quebras de linha como \\n (escapadas), nunca linha de verdade.'
+        + '\n\n# A conversa até aqui\n\n' + historico
+        + '\n\nResponda com exatamente UM bloco marcado.';
     // --dangerously-skip-permissions: mesma razão do caminho ORCA acima —
     // a skill já proíbe o Claude Code de usar suas próprias ferramentas
     // nativas; a flag só evita que ele pare pedindo permissão pra si mesmo
     // numa chamada headless sem ninguém pra responder.
+    // O prompt vai por STDIN, nunca por argumento: argumento tem limite de
+    // tamanho (a conversa cresce) e qualquer conteúdo começando com traço
+    // seria lido como opção. stdin não tem nenhum dos dois problemas.
     const saida = execFileSync('claude', [
-        '-p', prompt,
+        '-p',
         '--output-format', 'json',
         '--dangerously-skip-permissions',
-    ], { encoding: 'utf-8', timeout: 180000 });
+    ], { encoding: 'utf-8', timeout: 180000, input: prompt, maxBuffer: 32 * 1024 * 1024 });
     const r = JSON.parse(saida);
     emitirDecisao(r.result || '', onEvent);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "8.10.5",
+  "version": "8.11.1",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Modelos grátis. Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {

package/studio/web/js/player.js

@@ -71,6 +71,16 @@
       montarTransporte();
       prepararTrilha();
       tocar();
+      // /v/<id>#gravar: o CLI abre assim quando o usuário pede "baixa o
+      // vídeo". O navegador pede a permissão de tela (a "aprovação"), o
+      // usuário aceita, o vídeo roda do zero gravando e baixa no fim —
+      // nenhuma chamada de IA no caminho inteiro.
+      if (location.hash.indexOf("gravar") !== -1) {
+        setTimeout(function () {
+          aviso("aceite a permissão para gravar — o download sai no fim", 4000);
+          iniciarGravacao();
+        }, 700);
+      }
     }
   }
 
@@ -400,8 +410,11 @@
       }
       var misto = new MediaStream(faixas);
       pedacos = [];
-      var tipo = MediaRecorder.isTypeSupported("video/webm;codecs=vp9,opus")
-        ? "video/webm;codecs=vp9,opus" : "video/webm";
+      // MP4 primeiro, quando o navegador sabe gravar mp4 (Safari sabe;
+      // Chrome grava webm). O usuário pediu "baixar em mp4": onde dá, dá.
+      var tipo = MediaRecorder.isTypeSupported("video/mp4") ? "video/mp4"
+        : MediaRecorder.isTypeSupported("video/webm;codecs=vp9,opus")
+          ? "video/webm;codecs=vp9,opus" : "video/webm";
       gravador = new MediaRecorder(misto, { mimeType: tipo, videoBitsPerSecond: 8000000 });
       gravador.ondataavailable = function (ev) { if (ev.data.size) pedacos.push(ev.data); };
       gravador.onstop = baixarGravacao;
@@ -424,14 +437,16 @@
   }
 
   function baixarGravacao() {
-    var blob = new Blob(pedacos, { type: "video/webm" });
+    var mime = (gravador && gravador.mimeType) || "video/webm";
+    var ext = /mp4/.test(mime) ? ".mp4" : ".webm";
+    var blob = new Blob(pedacos, { type: mime.split(";")[0] });
     var url = URL.createObjectURL(blob);
     var a = document.createElement("a");
     a.href = url;
-    a.download = (arq.titulo || "video").replace(/[^\w\-]+/g, "-").toLowerCase() + ".webm";
+    a.download = (arq.titulo || "video").replace(/[^\w\-]+/g, "-").toLowerCase() + ext;
     a.click();
     setTimeout(function () { URL.revokeObjectURL(url); }, 4000);
-    aviso("vídeo salvo em .webm", 2600);
+    aviso("vídeo salvo em " + ext, 2600);
   }
 
   /* -------------------------------------------------------------- print -- */