primocode 8.0.0 → 8.0.1

package/lib/act.js

@@ -299,9 +299,19 @@ async function runAct(userPrompt, opts) {
             const result = await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual });
             logResult(tc.name, result, profundidade);
 
-            // Uma escrita bem-sucedida limpa a dívida: o agente se corrigiu.
-            if (result && result.ok === false) falhasPendentes.push(`${tc.name}(${tc.arguments?.path || ''}): ${result.error}`);
-            else if (['write_file', 'edit_file'].includes(tc.name)) falhasPendentes.length = 0;
+            // Uma escrita bem-sucedida limpa a dívida — mas só a do MESMO
+            // arquivo. Escrever algo sem relação (ou um run_shell qualquer)
+            // não corrige um teste quebrado noutro lugar; antes isto zerava
+            // a lista inteira e o agente conseguia dizer "concluído" com uma
+            // falha real ainda pendente.
+            if (result && result.ok === false) {
+                falhasPendentes.push(`${tc.name}(${tc.arguments?.path || ''}): ${result.error}`);
+            } else if (['write_file', 'edit_file'].includes(tc.name) && tc.arguments?.path) {
+                const alvo = tc.arguments.path;
+                const mantidas = falhasPendentes.filter((f) => !f.includes(`(${alvo})`));
+                falhasPendentes.length = 0;
+                falhasPendentes.push(...mantidas);
+            }
 
             messages.push({ role: 'tool', tool_call_id: tc.id, content: summarizeForModel(result) });
         }

package/lib/desktop.js

@@ -19,7 +19,9 @@ const os = require('os');
 const PLATFORM = os.platform();
 
 function hasCmd(cmd) {
-    try { execSync(`which ${cmd} || where ${cmd}`, { stdio: 'ignore' }); return true; } catch { return false; }
+    // cmd pode vir de texto do usuário (desktop_open_app com nome sem alias
+    // conhecido) — sem aspas aqui, um ";"/"&&" no meio vira comando extra.
+    try { execSync(`which ${sh1(cmd)} || where ${sh1(cmd)}`, { stdio: 'ignore' }); return true; } catch { return false; }
 }
 
 // Detectar ferramenta disponível

package/lib/referencia.js

@@ -64,11 +64,15 @@ function viaProxy(alvo, { timeout }) {
     });
 }
 
-function pegar(url, { timeout = TIMEOUT_MS } = {}) {
+function pegar(url, { timeout = TIMEOUT_MS, saltos = 0 } = {}) {
     return new Promise((resolve) => {
         let req;
         const alvo = (() => { try { return new URL(url); } catch { return null; } })();
         if (!alvo) return resolve(null);
+        // 5 saltos cobre qualquer doc real; sem teto, um redirect em loop
+        // (A→B→A→...) trava essa fonte — e a pesquisa inteira — para sempre.
+        if (saltos > 5) return resolve(null);
+        const cliente = alvo.protocol === 'http:' ? http : https;
 
         const opcoes = {
             headers: {
@@ -88,12 +92,12 @@ function pegar(url, { timeout = TIMEOUT_MS } = {}) {
         abrir.then((cfg) => {
             if (!cfg) return resolve(null);
             try {
-                req = https.get(url, cfg, (res) => {
-                // Redirecionamento: segue uma vez, o suficiente para docs.
+                req = cliente.get(url, cfg, (res) => {
+                // Redirecionamento: segue até o teto de saltos acima.
                 if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
                     res.resume();
                     const destino = new URL(res.headers.location, url).href;
-                    return pegar(destino, { timeout }).then(resolve);
+                    return pegar(destino, { timeout, saltos: saltos + 1 }).then(resolve);
                 }
                 if (res.statusCode !== 200) { res.resume(); return resolve(null); }
                 let corpo = '';

package/lib/tools.js

@@ -289,7 +289,7 @@ function multiEdit({ path: rawPath, edits }, projectDir) {
         if (ocorrencias > 1 && !replace_all) {
             return { ok: false, error: `edit ${i + 1}: trecho aparece ${ocorrencias}x — use replace_all ou inclua mais contexto para torná-lo único` };
         }
-        conteudo = replace_all ? conteudo.split(old_string).join(new_string) : conteudo.replace(old_string, new_string);
+        conteudo = replace_all ? conteudo.split(old_string).join(new_string ?? '') : conteudo.replace(old_string, new_string ?? '');
         substituicoes++;
     }
 
@@ -422,7 +422,10 @@ async function despachar(name, args, ctx) {
                 return texto == null ? { ok: false, error: 'nada na página (ou seletor não encontrado)' } : { ok: true, text: texto };
             }
             case 'browser_screenshot':
-                return browser.screenshot(args.path ? resolveInProject(args.path, projectDir) : undefined);
+                // Sem path, cai num nome-padrão — mas SEMPRE dentro do projeto: sem
+                // isso o arquivo ia para o cwd real do processo, não para a pasta
+                // virtual que o CLI mostra ao usuário (o processo nunca faz chdir).
+                return browser.screenshot(resolveInProject(args.path || `screenshot-${Date.now()}.png`, projectDir));
             case 'browser_scroll':
                 return browser.scroll(args.dy != null ? args.dy : 600);
             case 'browser_wait':
@@ -432,7 +435,9 @@ async function despachar(name, args, ctx) {
 
             // ── Desktop físico — mouse, teclado e tela do usuário ───────────
             case 'desktop_screenshot':
-                return desktop.screenshot(args.path ? resolveInProject(args.path, projectDir) : undefined);
+                // Mesmo motivo do browser_screenshot: nome-padrão também precisa
+                // resolver dentro do projeto, não do cwd real do processo.
+                return desktop.screenshot(resolveInProject(args.path || `desktop-${Date.now()}.png`, projectDir));
             case 'desktop_click':
                 return desktop.click(args.x, args.y, args.button || 'left');
             case 'desktop_move':
@@ -484,24 +489,6 @@ async function despachar(name, args, ctx) {
     }
 }
 
-function applyCodeBlocks(response) {
-    const regex = /```[\w]*\n([\s\S]*?)```/g;
-    const applied = [];
-    let match;
-    while ((match = regex.exec(response || '')) !== null) {
-        const block = match[1];
-        const nome = block.match(/\/\/\s*filename:\s*(.+)/);
-        if (!nome) continue;
-        const filename = nome[1].trim();
-        const content = block.replace(/\/\/\s*filename:.+\n?/, '');
-        const created = !fs.existsSync(filename);
-        fs.mkdirSync(path.dirname(filename), { recursive: true });
-        fs.writeFileSync(filename, content, 'utf-8');
-        applied.push({ path: filename, created });
-    }
-    return applied;
-}
-
 async function uninstall() {
     const configDir = path.join(os.homedir(), '.primocode');
     console.log('Removendo PrimoCode…');
@@ -519,7 +506,7 @@ async function uninstall() {
 }
 
 module.exports = {
-    fmtBytes, treeDir, applyCodeBlocks, runShell, openInBrowser, runInNewTerminal,
+    fmtBytes, treeDir, runShell, openInBrowser, runInNewTerminal,
     execute, uninstall, resolveInProject, globToRegex, globFiles, grepFiles, editFile,
     multiEdit, writeTodos, getTodos,
 };

package/package.json

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

@@ -9,6 +9,7 @@ Só biblioteca padrão do Python. Nada para instalar.
 """
 
 import base64
+import functools
 import json
 import mimetypes
 import os
@@ -98,10 +99,17 @@ POR_SLUG = {f["slug"]: f for f in FERRAMENTAS_INFO}
 
 # -------------------------------------------------------------- utilidades --
 
-def slugify(texto):
+def _normaliza(texto, tamanho):
+    """NFKD → ASCII → não-alfanumérico vira hífen → minúsculo → corta.
+    Compartilhada por slugify() e nome_seguro(), que faziam a mesma conta
+    com um corte de tamanho diferente cada uma."""
     texto = unicodedata.normalize("NFKD", texto or "").encode("ascii", "ignore").decode()
     texto = re.sub(r"[^a-zA-Z0-9]+", "-", texto).strip("-").lower()
-    return (texto or "arquivo")[:40]
+    return (texto or "arquivo")[:tamanho]
+
+
+def slugify(texto):
+    return _normaliza(texto, 40)
 
 
 def caminho(arq_id):
@@ -163,10 +171,7 @@ mimetypes.add_type("audio/mp4", ".m4a")
 
 def nome_seguro(nome):
     base, ext = os.path.splitext(nome or "arquivo")
-    ext = ext.lower()
-    base = unicodedata.normalize("NFKD", base).encode("ascii", "ignore").decode()
-    base = re.sub(r"[^a-zA-Z0-9]+", "-", base).strip("-").lower()[:48] or "arquivo"
-    return base, ext
+    return _normaliza(base, 48), ext.lower()
 
 
 def listar_midia():
@@ -218,16 +223,31 @@ def guardar_midia(dados):
 
 
 def criar(dados):
-    ferramenta = (dados.get("ferramenta") or "prisma").lower()
+    # O cliente é um agente de IA falando JSON cru — um tipo errado aqui
+    # (titulo como lista, por exemplo) não pode virar AttributeError sem
+    # resposta HTTP nenhuma; melhor um 400 com o motivo.
+    ferramenta_bruta = dados.get("ferramenta")
+    if ferramenta_bruta is not None and not isinstance(ferramenta_bruta, str):
+        raise ValueError("ferramenta precisa ser texto")
+    ferramenta = (ferramenta_bruta or "prisma").lower()
     if ferramenta not in POR_SLUG:
         return None
-    titulo = (dados.get("titulo") or "Sem título").strip()
+
+    titulo_bruto = dados.get("titulo")
+    if titulo_bruto is not None and not isinstance(titulo_bruto, str):
+        raise ValueError("titulo precisa ser texto")
+    titulo = (titulo_bruto or "Sem título").strip()
+
+    doc = dados.get("doc")
+    if doc is not None and not isinstance(doc, dict):
+        raise ValueError("doc precisa ser um objeto")
+
     arq_id = ferramenta + "-" + slugify(titulo) + "-" + uuid.uuid4().hex[:5]
     return gravar({
         "id": arq_id,
         "ferramenta": ferramenta,
         "titulo": titulo,
-        "doc": dados.get("doc") or exemplo(ferramenta),
+        "doc": doc or exemplo(ferramenta),
     })
 
 
@@ -311,6 +331,23 @@ def manual():
 
 # ----------------------------------------------------------------- handler --
 
+def seguro(metodo):
+    """Qualquer exceção não prevista na rota vira 500 em JSON, não conexão
+    fechada sem resposta nenhuma — era o comportamento padrão do
+    BaseHTTPRequestHandler para exceção não tratada num do_*, e o cliente (o
+    agente de IA) não tem como interpretar uma conexão que só morre."""
+    @functools.wraps(metodo)
+    def envolto(self, *a, **kw):
+        try:
+            return metodo(self, *a, **kw)
+        except Exception as e:
+            try:
+                self.js({"erro": "erro interno: %s" % e}, 500)
+            except Exception:
+                pass
+    return envolto
+
+
 class Handler(SimpleHTTPRequestHandler):
     server_version = "PrimoCode/1.0"
 
@@ -360,6 +397,7 @@ class Handler(SimpleHTTPRequestHandler):
 
     # -------------------------------------------------------------- rotas --
 
+    @seguro
     def do_GET(self):
         p = urlparse(self.path).path
 
@@ -426,10 +464,17 @@ class Handler(SimpleHTTPRequestHandler):
         if faixa:
             m = re.match(r"bytes=(\d*)-(\d*)", faixa)
             if m:
-                if m.group(1):
-                    inicio = int(m.group(1))
-                if m.group(2):
-                    fim = min(int(m.group(2)), tamanho - 1)
+                if not m.group(1) and m.group(2):
+                    # "bytes=-500" é sufixo HTTP válido: os ÚLTIMOS 500 bytes,
+                    # não os primeiros 500 — sem este caso à parte, group(2)
+                    # virava fim absoluto e o pedido servia o pedaço errado.
+                    inicio = max(0, tamanho - int(m.group(2)))
+                    fim = tamanho - 1
+                else:
+                    if m.group(1):
+                        inicio = int(m.group(1))
+                    if m.group(2):
+                        fim = min(int(m.group(2)), tamanho - 1)
                 if inicio > fim or inicio >= tamanho:
                     self.send_response(416)
                     self.send_header("Content-Range", "bytes */%d" % tamanho)
@@ -455,13 +500,18 @@ class Handler(SimpleHTTPRequestHandler):
                 self.wfile.write(pedaco)
                 restante -= len(pedaco)
 
+    @seguro
     def do_POST(self):
-        if urlparse(self.path).path == "/api/midia":
+        rota = urlparse(self.path).path
+        if rota == "/api/midia":
             corpo, status = guardar_midia(self.corpo())
             return self.js(corpo, status)
 
-        if urlparse(self.path).path == "/api/arquivos":
-            a = criar(self.corpo())
+        if rota == "/api/arquivos":
+            try:
+                a = criar(self.corpo())
+            except ValueError as e:
+                return self.js({"erro": str(e)}, 400)
             if not a:
                 return self.js({"erro": "ferramenta inválida",
                                 "validas": list(POR_SLUG)}, 400)
@@ -475,6 +525,7 @@ class Handler(SimpleHTTPRequestHandler):
             }, 201)
         return self.js({"erro": "não encontrado"}, 404)
 
+    @seguro
     def do_PUT(self):
         m = re.fullmatch(r"/api/arquivos/([^/]+)", urlparse(self.path).path)
         if not m:
@@ -483,13 +534,21 @@ class Handler(SimpleHTTPRequestHandler):
         if not a:
             return self.js({"erro": "não encontrado"}, 404)
         dados = self.corpo()
+        # Mesma validação de criar(): sem isso, um PUT com titulo/doc do tipo
+        # errado grava sujeira que só quebra depois, no consumo (export etc).
+        if "titulo" in dados and dados["titulo"] is not None and not isinstance(dados["titulo"], str):
+            return self.js({"erro": "titulo precisa ser texto"}, 400)
+        if "doc" in dados and dados["doc"] is not None and not isinstance(dados["doc"], dict):
+            return self.js({"erro": "doc precisa ser um objeto"}, 400)
         for chave in ("titulo", "doc"):
             if chave in dados:
                 a[chave] = dados[chave]
         return self.js(gravar(a))
 
+    @seguro
     def do_DELETE(self):
-        m = re.fullmatch(r"/api/midia/([^/]+)", urlparse(self.path).path)
+        rota = urlparse(self.path).path
+        m = re.fullmatch(r"/api/midia/([^/]+)", rota)
         if m:
             nome = unquote(m.group(1))
             alvo = os.path.join(MIDIA, nome)
@@ -498,7 +557,7 @@ class Handler(SimpleHTTPRequestHandler):
                 return self.js({"ok": True})
             return self.js({"erro": "não encontrado"}, 404)
 
-        m = re.fullmatch(r"/api/arquivos/([^/]+)", urlparse(self.path).path)
+        m = re.fullmatch(r"/api/arquivos/([^/]+)", rota)
         c = caminho(m.group(1)) if m else None
         if c and os.path.exists(c):
             os.remove(c)
@@ -535,7 +594,7 @@ def csv_celula(valor):
         if valor == int(valor):
             valor = int(valor)
     s = "" if valor is None else str(valor)
-    return '"%s"' % s.replace('"', '""') if re.search(r'[",\n]', s) else s
+    return '"%s"' % s.replace('"', '""') if re.search(r'[",\n\r]', s) else s
 
 
 # ------------------------------------------------- fórmulas (espelha o JS) --
@@ -602,7 +661,11 @@ def calcular_aba(aba):
     linhas = [list(l) for l in aba.get("linhas", [])]
 
     def celula(c, l, prof):
-        if prof > 24 or l >= len(linhas) or c >= len(linhas[l]):
+        # l/c negativos (referência tipo "A0", que vira índice -1) não podem
+        # passar: índice negativo do Python "funciona" contando do fim da
+        # lista, e a última linha da planilha aparecia como resposta de uma
+        # referência inválida em vez de virar 0.
+        if prof > 24 or l < 0 or c < 0 or l >= len(linhas) or c >= len(linhas[l]):
             return 0
         bruto = linhas[l][c]
         if isinstance(bruto, str) and bruto.startswith("="):
@@ -642,7 +705,14 @@ def calcular_aba(aba):
                 elif parte:
                     # qualquer outro argumento é uma expressão: resolve antes
                     vals.append(_num(avaliar(parte, prof)))
-            return repr(f(vals))
+            try:
+                # MAIOR/MENOR estouram IndexError com k maior que o intervalo;
+                # POT estoura OverflowError com base/expoente grandes demais.
+                # Uma fórmula ruim vira "#ERRO" NESSA célula, não derruba a
+                # exportação inteira (mesma regra do eval() logo abaixo).
+                return repr(f(vals))
+            except Exception:
+                return "#ERRO"
 
         # repete até esgotar: resolve de dentro para fora em fórmula aninhada
         e, voltas = expr, 0