primocode 8.10.0 → 8.10.2

package/bin/primocode.js

@@ -550,10 +550,19 @@ async function sendPrompt(userText) {
         let jaFeito = '';
         for (let i = 0; i < passos.length; i++) {
             if (i > 0) console.log(c.dim(`  ⎿ ${passos[i].titulo}`));
-            const pedido = i === 0 ? passos[i].pedido
-                : `${passos[i].pedido}\n\nO QUE JÁ FOI FEITO ANTES (use estes fatos, não pesquise de novo):\n${jaFeito}`;
-
-            r = await runAct(pedido, {
+            // Só fato de passo CONCLUÍDO entra aqui. Num pedido real o passo de
+            // pesquisa morreu e o texto "Parei sem concluir..." foi injetado
+            // como "use estes fatos" — e o passo seguinte obedeceu: criou o
+            // vídeo sem fato nenhum, proibido de pesquisar.
+            const contexto = !jaFeito ? ''
+                : `\n\nO QUE JÁ FOI FEITO ANTES (use estes fatos, não pesquise de novo):\n${jaFeito}`;
+            const semFatos = i > 0 && !jaFeito
+                ? '\n\nATENÇÃO: o passo anterior não trouxe fatos. Trabalhe só com o que está no pedido. '
+                  + 'É PROIBIDO inventar dado de empresa, data, preço ou pessoa — na dúvida, não afirme.'
+                : '';
+            const pedido = passos[i].pedido + contexto + semFatos;
+
+            const rodarPasso = () => runAct(pedido, {
                 server: state.config.server,
                 model: state.config.model,
                 effort: state.config.effort,
@@ -568,7 +577,19 @@ async function sendPrompt(userText) {
                 ensureWorkDir: plan.pending ? () => createPendingProject(plan) : null,
                 motor: state.engine === 'claude-code' ? claudeEngine : api,
             });
-            jaFeito = String((r.assistantMessage && r.assistantMessage.content) || '').slice(0, 1200);
+
+            r = await rodarPasso();
+            // Passo que desistiu (modelo mudo, voltas esgotadas) ganha UMA
+            // segunda chance — costuma ser tropeço transitório do modelo
+            // grátis. Falhou de novo: o plano segue com o aviso de "sem
+            // fatos", nunca com o texto da falha fantasiado de resultado.
+            if (!r.parado && r.concluiu === false && passos.length > 1) {
+                console.log(c.dim('  ⎿ o passo não concluiu — tentando de novo'));
+                r = await rodarPasso();
+            }
+            jaFeito = (r.concluiu !== false)
+                ? String((r.assistantMessage && r.assistantMessage.content) || '').slice(0, 1200)
+                : '';
             if (r.parado) break;   // Esc Esc no meio do plano para o plano inteiro
         }
         state.history.push({ role: 'user', content: userText });

package/lib/act.js

@@ -362,6 +362,12 @@ async function runAct(userPrompt, opts) {
     let compactacoes = 0;
     const MAX_COMPACTACOES = 2;
 
+    // O provedor recusa chamada de função malformada com um 400 que dizia
+    // "Failed to call a function. Please adjust your prompt." NA CARA do
+    // usuário — que não tem prompt nenhum para ajustar. É o modelo tropeçando
+    // ao escrever o JSON da chamada, e quase sempre acerta na segunda.
+    let funcoesQuebradas = 0;
+
     let voltas = 0;
     for (let iteration = 0; iteration < MAX_ITERATIONS && !PARAR; iteration++) {
         voltas++;
@@ -409,6 +415,19 @@ async function runAct(userPrompt, opts) {
         emVoo = null;
         if (PARAR) break;
 
+        // Chamada de função malformada: o modelo errou a SINTAXE da chamada,
+        // não a tarefa. Repetir a mesma rodada quase sempre resolve — e sem
+        // isto o 400 cru do provedor ("Failed to call a function. Please
+        // 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++;
+            if (!subagent) console.log(ident(profundidade) + c.dim('  ⎿ o modelo tropeçou na chamada — tentando de novo'));
+            iteration--;
+            continue;
+        }
+
         if (streamError && ehTetoDeToken(streamError) && compactacoes < MAX_COMPACTACOES && !PARAR) {
             compactacoes++;
             const antes = messages.length;
@@ -422,9 +441,11 @@ async function runAct(userPrompt, opts) {
 
         if (streamError) {
             const amigavel = friendlyError(streamError);
-            if (subagent) return { assistantMessage: { role: 'assistant', content: `Subagente falhou: ${amigavel}` } };
+            if (subagent) return { assistantMessage: { role: 'assistant', content: `Subagente falhou: ${amigavel}` }, concluiu: false };
             console.log('\n' + c.err(amigavel));
-            return { assistantMessage: { role: 'assistant', content: amigavel } };
+            // concluiu: false — o plano de passos não pode tratar um erro de
+            // provedor como resultado e passá-lo adiante como "fato".
+            return { assistantMessage: { role: 'assistant', content: amigavel }, concluiu: false };
         }
 
         // Sem tool_calls: o modelo respondeu e acabou.
@@ -561,6 +582,11 @@ async function runAct(userPrompt, opts) {
         }
     }
 
+    // O que o modelo entregou por vontade própria, ANTES dos textos de
+    // desistência. É esta a diferença que o plano de passos precisa: um passo
+    // que "parou sem concluir" não pode virar fato para o passo seguinte.
+    const concluiu = Boolean(finalText) && !PARAR;
+
     if (PARAR && !finalText) {
         finalText = 'Parado por você (Esc Esc). O que já foi feito, ficou feito.';
         if (!subagent) console.log('\n' + c.warn('⏹ ' + finalText));
@@ -594,6 +620,7 @@ async function runAct(userPrompt, opts) {
         // INTEIRO, não só o passo — senão o próximo passo começa logo depois
         // de o usuário ter mandado parar.
         parado: PARAR,
+        concluiu,
     };
 }
 

package/lib/studio.js

@@ -84,12 +84,12 @@ function copiar(de, para) {
         for (const item of fs.readdirSync(de)) copiar(path.join(de, item), path.join(para, item));
         return;
     }
-    let precisa = true;
-    try {
-        const alvo = fs.statSync(para);
-        precisa = alvo.size !== st.size || alvo.mtimeMs < st.mtimeMs;
-    } catch {}
-    if (precisa) fs.copyFileSync(de, para);
+    // Copia SEMPRE. A comparação esperta (tamanho + data) deixava passar
+    // arquivo alterado de mesmo tamanho: o npm instala com data antiga
+    // (1985, de propósito, por reprodutibilidade) e o teste de mtime nunca
+    // disparava. O que o usuário criou não corre risco — arquivos/ e midia/
+    // não estão em COPIAVEIS.
+    fs.copyFileSync(de, para);
 }
 
 function prepararCasa() {
@@ -139,10 +139,64 @@ async function estaNoAr() {
 // Uma subida por vez: sem esta trava, duas tools chamadas no mesmo turno
 // disparariam dois servidores na mesma porta e o segundo morreria com
 // "address in use" — barulho por nada.
+/** A assinatura do server.py que está NO DISCO — a versão que deveria rodar. */
+function assinaturaDoDisco() {
+    try {
+        const corpo = fs.readFileSync(path.join(CASA, 'server.py'));
+        return require('crypto').createHash('sha1').update(corpo).digest('hex').slice(0, 12);
+    } catch { return null; }
+}
+
+/** A assinatura do processo que está NO AR — a versão que roda de fato. */
+async function assinaturaNoAr() {
+    try { return (await pedir('GET', '/api/versao', null, 1500)).assinatura || null; }
+    catch { return null; }   // servidor antigo não tem a rota — também é "desatualizado"
+}
+
+/**
+ * Derruba o Studio que está no ar. Primeiro pelo caminho limpo (/api/sair);
+ * se for um servidor antigo, que não tem a rota, pelo sistema.
+ */
+async function derrubar() {
+    try { await pedir('POST', '/api/sair', {}, 1500); } catch {}
+    for (let i = 0; i < 10; i++) {
+        await new Promise((r) => setTimeout(r, 300));
+        if (!(await estaNoAr())) return true;
+    }
+    // Servidor antigo: sem /api/sair. Mata pelo padrão da linha de comando.
+    try {
+        const { execSync } = require('child_process');
+        if (os.platform() === 'win32') {
+            execSync('powershell -NoProfile -Command "Get-CimInstance Win32_Process | ' +
+                "Where-Object {$_.CommandLine -like '*primocode*studio*server.py*'} | " +
+                'ForEach-Object { Stop-Process -Id $_.ProcessId -Force }"', { stdio: 'ignore' });
+        } else {
+            execSync("pkill -f '[.]primocode/studio/server.py'", { stdio: 'ignore' });
+        }
+    } catch {}
+    for (let i = 0; i < 10; i++) {
+        await new Promise((r) => setTimeout(r, 300));
+        if (!(await estaNoAr())) return true;
+    }
+    return !(await estaNoAr());
+}
+
 let subindo = null;
 
 async function garantirNoAr() {
-    if (await estaNoAr()) return { ok: true, url: BASE, jaEstava: true };
+    if (await estaNoAr()) {
+        // O npm pode ter trocado o código no disco DEPOIS de este processo
+        // subir — e aí o Studio no ar é o antigo, servindo o bug que o
+        // update corrigiu. Atualiza o disco e compara as assinaturas; se
+        // divergirem, reinicia. Na véspera de uma apresentação, "atualizei
+        // mas continua igual" é o pior modo de falha que existe.
+        prepararCasa();
+        const doDisco = assinaturaDoDisco();
+        const noAr = await assinaturaNoAr();
+        if (!doDisco || (noAr && noAr === doDisco)) return { ok: true, url: BASE, jaEstava: true };
+        await derrubar();
+        // cai para o caminho de subida normal, já com o código novo
+    }
     if (subindo) return subindo;
 
     subindo = (async () => {
@@ -202,7 +256,26 @@ const manual = () => comStudio(async () => ({ ok: true, ...(await pedir('GET', '
 const ferramentas = () => comStudio(async () => ({ ok: true, ferramentas: await pedir('GET', '/api/ferramentas') }));
 const spec = (slug) => comStudio(async () => ({ ok: true, spec: await pedir('GET', `/api/ferramentas/${encodeURIComponent(slug)}`) }));
 const listar = () => comStudio(async () => ({ ok: true, arquivos: await pedir('GET', '/api/arquivos') }));
-const ler = (id) => comStudio(async () => ({ ok: true, arquivo: await pedir('GET', `/api/arquivos/${encodeURIComponent(id)}`) }));
+// 404 de id é quase sempre id INVENTADO: num pedido real o agente criou o
+// arquivo, recebeu "corte-founders-ea74b" de volta, e chamou studio_ler com
+// "imersao-foulders-ai" — um id que ele imaginou. O erro seco ("não
+// encontrado") não dizia isso, e ele insistia. O erro que ensina, diz.
+async function comIdReal(id, fn) {
+    try {
+        return await fn();
+    } catch (e) {
+        if (!/HTTP 404/.test(String(e && e.message))) throw e;
+        let existem = [];
+        try { existem = (await pedir('GET', '/api/arquivos')).map((a) => a.id).slice(0, 8); } catch {}
+        return {
+            ok: false,
+            error: `O id "${id}" não existe. NÃO invente id: use EXATAMENTE o campo "id" que studio_criar devolveu.`
+                + (existem.length ? ` Os que existem agora: ${existem.join(', ')}.` : ''),
+        };
+    }
+}
+
+const ler = (id) => comStudio(() => comIdReal(id, async () => ({ ok: true, arquivo: await pedir('GET', `/api/arquivos/${encodeURIComponent(id)}`) })));
 
 const criar = ({ ferramenta, titulo, doc }) => comStudio(async () => {
     if (!ferramenta) return { ok: false, error: 'Diga a ferramenta: prisma, tela, prosa, grade, corte ou traco.' };
@@ -211,14 +284,14 @@ const criar = ({ ferramenta, titulo, doc }) => comStudio(async () => {
     return { ok: true, ...r };
 });
 
-const atualizar = ({ id, titulo, doc }) => comStudio(async () => {
+const atualizar = ({ id, titulo, doc }) => comStudio(() => comIdReal(id, async () => {
     if (!id) return { ok: false, error: 'Falta o id do arquivo.' };
     const corpo = {};
     if (titulo != null) corpo.titulo = titulo;
     if (doc != null) corpo.doc = doc;
     const r = await pedir('PUT', `/api/arquivos/${encodeURIComponent(id)}`, corpo);
     return { ok: true, ...r };
-});
+}));
 
 // ── Mídia: a imagem de fundo e a música do usuário ───────────────────────
 // Sem isto o agente não tinha como pôr foto de fundo nem trilha própria: a
@@ -234,7 +307,15 @@ const midiaListar = () => comStudio(async () => ({ ok: true, midia: await pedir(
 const midiaEnviar = ({ arquivo, nome }) => comStudio(async () => {
     if (!arquivo) return { ok: false, error: 'Diga o caminho do arquivo (arquivo: "foto.jpg").' };
     const caminho = path.resolve(arquivo);
-    if (!fs.existsSync(caminho)) return { ok: false, error: `Arquivo não existe: ${arquivo}` };
+    if (!fs.existsSync(caminho)) {
+        return {
+            ok: false,
+            error: `Arquivo não existe: ${arquivo}. NÃO invente arquivo de mídia — num pedido real o agente `
+                + 'tentou fundo.jpg, trilha.mp3 e logo.png que nunca existiram. Sem arquivo do usuário, siga sem mídia: '
+                + 'fundo pode ser "aurora"/"raios"/"brilho" (gerados), e trilha pode ser gerada — '
+                + '"trilha":{"tipo":"gerada","estilo":"epico"}. O vídeo fica pronto do mesmo jeito.',
+        };
+    }
 
     const ext = path.extname(caminho).toLowerCase();
     if (!TIPOS_MIDIA[ext]) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "8.10.0",
+  "version": "8.10.2",
   "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/server.py

@@ -9,6 +9,7 @@ Só biblioteca padrão do Python. Nada para instalar.
 """
 
 import base64
+import hashlib
 import functools
 import json
 import mimetypes
@@ -30,6 +31,19 @@ FERRAMENTAS = os.path.join(RAIZ, "ferramentas")
 MIDIA = os.path.join(RAIZ, "midia")
 PORTA = int(sys.argv[1]) if len(sys.argv) > 1 else 7777
 
+def _assinatura():
+    """SHA-1 do próprio arquivo, lido NA SUBIDA. Se o npm trocar o código no
+    disco depois, o processo no ar continua respondendo a assinatura antiga —
+    e é exatamente essa diferença que o CLI usa para saber que precisa
+    reiniciar o Studio em vez de servir a versão velha para sempre."""
+    try:
+        with open(os.path.abspath(__file__), "rb") as fh:
+            return hashlib.sha1(fh.read()).hexdigest()[:12]
+    except Exception:
+        return "?"
+
+ASSINATURA = _assinatura()
+
 # 60 MB por arquivo: cobre faixa longa em mp3 e foto de câmera sem susto
 LIMITE_MIDIA = 60 * 1024 * 1024
 
@@ -506,6 +520,9 @@ class Handler(SimpleHTTPRequestHandler):
                     texto = fh.read()
             return self.txt(texto or json.dumps(info, ensure_ascii=False, indent=2))
 
+        if p == "/api/versao":
+            return self.js({"assinatura": ASSINATURA})
+
         if p == "/api/voz":
             return self.voz(urlparse(self.path).query)
         if p == "/api/voz/status":
@@ -752,6 +769,16 @@ class Handler(SimpleHTTPRequestHandler):
             corpo, status = guardar_midia(self.corpo())
             return self.js(corpo, status)
 
+        if rota == "/api/sair":
+            # Só o CLI chama, e só quando o código no disco mudou (update do
+            # npm). Sem isto o processo antigo ficava no ar servindo o bug que
+            # o update tinha acabado de corrigir. Responde antes de morrer,
+            # para quem pediu não ver erro de conexão.
+            self.js({"ok": True, "tchau": ASSINATURA})
+            import threading
+            threading.Thread(target=lambda: (time.sleep(0.3), os._exit(0)), daemon=True).start()
+            return
+
         if rota == "/api/arquivos":
             try:
                 a = criar(self.corpo())