primocode 8.10.4 → 8.11.0

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,7 +388,14 @@ 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.
+    const prompt = textoBootstrap()
+        + '\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

package/lib/tools.js

@@ -170,6 +170,9 @@ async function runShell(command, timeout = 60000, cwd) {
 // execFile com array de argumentos nunca passa por shell nenhum: "target" vira
 // UM argumento, não texto que um shell reinterpreta — sem isso, um valor tipo
 // `https://x/"; touch /tmp/pwned; echo "` injetava comando (achado de segurança).
+// Quando o auto-abrir do Studio abriu pela última vez — o freio das mil abas.
+let ultimaAberturaStudio = 0;
+
 function openInBrowser(target) {
     const p = os.platform();
     const [cmd, args, opener] = p === 'darwin' ? ['open', [target], 'open']
@@ -511,9 +514,20 @@ async function despachar(name, args, ctx) {
                 // uma tarefa inteira de tokens para o modelo redescobrir o
                 // link. Abrir é determinístico: não se gasta modelo com isso.
                 if (r && r.ok !== false && r.ver) {
-                    try { openInBrowser(r.ver); } catch {}
-                    r.abertoNoNavegador = true;
-                    r.aviso = 'JÁ ABERTO no navegador do usuário. Chame finish AGORA dizendo o que foi criado — não abra de novo, não leia de volta, não ajuste sem pedido.';
+                    // UMA aba por tarefa. O modelo às vezes cria três versões
+                    // seguidas, e abrir todas enchia o navegador do usuário de
+                    // abas — "abre 1000 versões". A primeira abre; as outras
+                    // são avisadas a ATUALIZAR a que já existe.
+                    const agora = Date.now();
+                    if (agora - ultimaAberturaStudio > 45000) {
+                        ultimaAberturaStudio = agora;
+                        try { openInBrowser(r.ver); } catch {}
+                        r.abertoNoNavegador = true;
+                        r.aviso = 'JÁ ABERTO no navegador do usuário. Chame finish AGORA dizendo o que foi criado — não abra de novo, não leia de volta, não ajuste sem pedido.';
+                    } else {
+                        r.aviso = `Você JÁ criou uma versão nesta tarefa, e ela está aberta no navegador. NÃO crie outra: `
+                            + `para mudar algo, use studio_atualizar com o id "${r.id}". Chame finish AGORA.`;
+                    }
                 }
                 return r;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "8.10.4",
+  "version": "8.11.0",
   "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/arquivos/corte-legado-teste.json

@@ -0,0 +1 @@
+{"id": "corte-legado-teste", "ferramenta": "corte", "titulo": "legado", "doc": {"tema": "meia-noite", "largura": 1080, "altura": 1920, "cenas": [{"duracao": "4s", "fundo": "aurora", "elementos": [{"tipo": "titulo", "texto": "Imersão Founders AI"}, {"tipo": "subtitulo", "conteudo": "Paris Group · Chapecó"}]}]}}

package/studio/arquivos/corte-legado2.json

@@ -0,0 +1 @@
+{"id": "corte-legado2", "ferramenta": "corte", "titulo": "legado2", "doc": {"tema": "meia-noite", "largura": 1080, "altura": 1920, "cenas": [{"duracao": "4s", "fundo": "aurora", "elementos": [{"tipo": "titulo", "texto": "Imersão Founders AI", "anim": "nenhuma"}, {"tipo": "subtitulo", "conteudo": "Paris Group · Chapecó", "anim": "nenhuma"}]}]}}

package/studio/arquivos/corte-ok-1270e.json

@@ -0,0 +1,22 @@
+{
+  "id": "corte-ok-1270e",
+  "ferramenta": "corte",
+  "titulo": "ok",
+  "doc": {
+    "tema": "brasa",
+    "cenas": [
+      {
+        "duracao": 3,
+        "elementos": [
+          {
+            "tipo": "texto",
+            "papel": "titulo",
+            "texto": "Founders AI",
+            "anim": "nenhuma"
+          }
+        ]
+      }
+    ]
+  },
+  "atualizado": "2026-08-16T17:50:21+00:00"
+}

package/studio/server.py

@@ -324,6 +324,14 @@ def validar_doc(modelo, doc):
                     'do usuário. O exemplo ensina o FORMATO; o conteúdo é seu: reescreva cada '
                     'cena com os fatos da tarefa (a pesquisa que você fez) e crie de novo.' % frase)
 
+    # Os tipos que o render.js de fato desenha. Elemento de tipo inventado
+    # ("titulo", "subtitulo", "video"...) passava na validação e caía no
+    # default do renderizador: texto cru de 16px num canvas de 1920 — ou nada,
+    # quando o texto estava noutro campo. Era o "vídeo com música mas tudo
+    # preto": documento válido na forma, invisível na tela.
+    TIPOS_VALIDOS = {"texto", "lista", "cartoes", "numeros", "tabela", "codigo",
+                     "citacao", "forma", "imagem", "icone", "grafico", "no", "conector"}
+
     if modelo == "cena":
         cenas = doc.get("cenas")
         if not isinstance(cenas, list) or not cenas:
@@ -337,9 +345,20 @@ def validar_doc(modelo, doc):
             if not isinstance(els, list) or not els:
                 return ('cena %d sem "elementos". Cada cena precisa de elementos:[...] — '
                         'ex.: {"tipo":"texto","texto":"..."}. Leia studio_spec e refaça.' % (i + 1))
+            dur = c.get("duracao")
+            if dur is not None and not isinstance(dur, (int, float)):
+                return ('cena %d com "duracao" que não é número (veio %r). Use número de segundos: '
+                        '"duracao": 3' % (i + 1, dur))
             for j, e in enumerate(els):
                 if not isinstance(e, dict) or not e.get("tipo"):
                     return 'elemento %d da cena %d sem "tipo" (texto, imagem, lista, numeros, forma...)' % (j + 1, i + 1)
+                if e.get("tipo") not in TIPOS_VALIDOS:
+                    return ('elemento %d da cena %d tem tipo "%s", que NÃO existe. Os tipos válidos são: %s. '
+                            'Para título use {"tipo":"texto","papel":"titulo","texto":"..."}.'
+                            % (j + 1, i + 1, e.get("tipo"), ", ".join(sorted(TIPOS_VALIDOS))))
+                if e.get("tipo") == "texto" and not (e.get("texto") or "").strip():
+                    return ('elemento %d da cena %d é "texto" mas o campo "texto" está vazio — o conteúdo '
+                            'vai SEMPRE no campo "texto".' % (j + 1, i + 1))
     elif modelo == "documento":
         blocos = doc.get("blocos")
         if not isinstance(blocos, list) or not blocos:

package/studio/web/js/player.js

@@ -30,7 +30,12 @@
     return String(Math.floor(s / 60)).padStart(2, "0") + ":" + String(s % 60).padStart(2, "0");
   }
 
-  function duracaoDe(i) { return (cenas[i] && cenas[i].duracao) || 4; }
+  function duracaoDe(i) {
+    /* "duracao": "3s" (texto) fazia acc virar concatenação e o relógio dava
+       vídeo de 00:00. Número são ou o padrão — nunca corrente de texto. */
+    var d = Number(cenas[i] && cenas[i].duracao);
+    return (isFinite(d) && d > 0) ? Math.min(60, d) : 4;
+  }
   function total() { return cenas.reduce(function (s, _, i) { return s + duracaoDe(i); }, 0); }
   function inicioDe(i) { var s = 0; for (var k = 0; k < i; k++) s += duracaoDe(k); return s; }
 
@@ -66,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);
+      }
     }
   }
 
@@ -395,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;
@@ -419,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 -- */

package/studio/web/js/render.js

@@ -137,9 +137,22 @@ function svgGrafico(e, l, a) {
 
 /* -------------------------------------------------------------- elementos */
 
+var TIPOS_CONHECIDOS = { texto: 1, lista: 1, cartoes: 1, numeros: 1, tabela: 1, codigo: 1,
+  citacao: 1, forma: 1, imagem: 1, icone: 1, grafico: 1, no: 1, conector: 1 };
+
 function renderElemento(e, ctx) {
   var no = document.createElement("div");
   var tipo = e.tipo || "texto";
+  /* Tipo inventado ("titulo", "subtitulo"...) caía num default sem estilo:
+     texto de 16px num canvas de 1920 — invisível — ou div vazio quando o
+     conteúdo estava noutro campo. O servidor novo recusa; documentos velhos
+     e outros clientes ganham a leitura generosa: vira texto de verdade. */
+  if (!TIPOS_CONHECIDOS[tipo]) {
+    e = { tipo: "texto", papel: /titulo|title/i.test(tipo) ? "titulo" : (e.papel || null),
+          texto: e.texto || e.conteudo || e.titulo || e.valor || e.legenda || "",
+          tamanho: e.tamanho, estilo: e.estilo, anim: e.anim, x: e.x, y: e.y, l: e.l, a: e.a };
+    tipo = "texto";
+  }
   no.className = "el " + tipo;
   no.dataset.tipo = tipo;