primocode 7.8.0 → 7.9.0

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v7.8.0
+# PrimoCode v7.9.0
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v7.8.0
+ ▐▛███▜▌   Primo Code v7.9.0
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/lib/act.js

@@ -271,7 +271,16 @@ async function runAct(userPrompt, opts) {
         }
     }
 
-    if (!finalText) finalText = 'Cheguei ao limite de passos sem concluir. Refaça o pedido em partes menores.';
+    // Nunca terminar em silêncio. Quando o modelo devolvia resposta vazia sem
+    // chamar tool, o usuário via a tela parar e mais nada — pior que erro, porque
+    // não dá nem para saber que acabou. Medido: um pedido de navegador morria assim
+    // depois de a primeira tentativa de seletor falhar.
+    if (!finalText) {
+        finalText = falhasPendentes.length
+            ? `Parei sem concluir. A última falha foi: ${falhasPendentes[falhasPendentes.length - 1]}`
+            : 'Parei sem concluir e sem explicação do modelo. Tente pedir de novo, em partes menores.';
+        if (!subagent) console.log('\n' + c.warn(finalText));
+    }
 
     // Nada de arquivo mexido = nada para lembrar. E grava em `pastaAtual`, não em
     // `projectDir`: quando a pasta do projeto nasceu no meio do caminho, a memória

package/lib/browser.js

@@ -57,6 +57,71 @@ function findChrome() {
     for (const p of candidates) {
         try { if (p && fs.existsSync(p)) return p; } catch {}
     }
+
+    // Último recurso: o navegador pode estar num disco montado ou numa pasta de
+    // aplicativos do usuário. Caso real medido nesta máquina: o Chrome 151 estava
+    // em `/Volumes/Google Chrome/Google Chrome.app` — a JANELA DO INSTALADOR,
+    // ainda montada. O usuário jurava (com razão) que tinha Chrome; a lista de
+    // caminhos padrão jurava que não. Os dois estavam certos.
+    const achado = procurarEmVolumes();
+    if (achado) return achado;
+
+    return null;
+}
+
+// Nomes de app e o binário dentro de cada um. Só Chromium: o Safari não fala o
+// protocolo de depuração que permite controlar a página.
+const APPS_MAC = [
+    ['Google Chrome.app', 'Google Chrome'],
+    ['Google Chrome Beta.app', 'Google Chrome Beta'],
+    ['Google Chrome Canary.app', 'Google Chrome Canary'],
+    ['Chromium.app', 'Chromium'],
+    ['Microsoft Edge.app', 'Microsoft Edge'],
+    ['Brave Browser.app', 'Brave Browser'],
+    ['Arc.app', 'Arc'],
+    ['Vivaldi.app', 'Vivaldi'],
+    ['Opera.app', 'Opera'],
+];
+
+/**
+ * Procura o navegador em `~/Applications` e nos discos montados em `/Volumes`.
+ *
+ * Um app rodando de dentro do `.dmg` funciona, mas é frágil: o disco é
+ * somente-leitura, o macOS o executa por AppTranslocation (caminho temporário
+ * aleatório) e ele desaparece na hora que o disco for ejetado. Achamos e usamos —
+ * e `avisoDeLocal()` diz ao usuário para arrastar o app para Aplicativos.
+ */
+function procurarEmVolumes() {
+    const bases = [];
+    try { bases.push(path.join(os.homedir(), 'Applications')); } catch {}
+    try {
+        for (const vol of fs.readdirSync('/Volumes')) bases.push(path.join('/Volumes', vol));
+    } catch {}
+
+    for (const base of bases) {
+        for (const [app, bin] of APPS_MAC) {
+            const alvo = path.join(base, app, 'Contents', 'MacOS', bin);
+            try { if (fs.existsSync(alvo)) return alvo; } catch {}
+        }
+    }
+    return null;
+}
+
+/**
+ * O navegador achado está num lugar problemático? Devolve o aviso, ou null.
+ *
+ * Não bloqueia nada: o controle funciona de dentro do disco montado. Só avisa,
+ * porque quem ejetar o disco vai ver a ferramenta parar de funcionar sem entender
+ * o motivo.
+ */
+function avisoDeLocal(caminho) {
+    if (!caminho) return null;
+    if (caminho.startsWith('/Volumes/')) {
+        const app = (caminho.match(/\/Volumes\/[^/]+\/([^/]+\.app)/) || [, 'o navegador'])[1];
+        return `${app} está rodando do disco de instalação, não instalado. `
+            + 'Funciona, mas para de funcionar quando você ejetar esse disco — '
+            + 'arraste o app para a pasta Aplicativos.';
+    }
     return null;
 }
 
@@ -104,11 +169,25 @@ class MiniWebSocket {
         this.onClose = () => {};
         this.closed = false;
     }
-    connect(url) {
+    connect(url, timeoutMs = 10000) {
         return new Promise((resolve, reject) => {
+            let pronto = false;
+            const relogio = setTimeout(() => {
+                if (pronto) return;
+                pronto = true;
+                try { if (this.socket) this.socket.destroy(); } catch {}
+                reject(new Error(`o navegador aceitou a conexão mas não completou o aperto de mão em ${Math.round(timeoutMs / 1000)}s`));
+            }, timeoutMs);
+            const terminar = (err) => {
+                if (pronto) return;
+                pronto = true;
+                clearTimeout(relogio);
+                err ? reject(err) : resolve();
+            };
+
             const u = new URL(url);
             const isSecure = u.protocol === 'wss:';
-            if (isSecure) return reject(new Error('wss:// não suportado (CDP local usa ws://)'));
+            if (isSecure) return terminar(new Error('wss:// não suportado (CDP local usa ws://)'));
             const key = crypto.randomBytes(16).toString('base64');
             const port = u.port || 80;
             const path = u.pathname + (u.search || '');
@@ -130,21 +209,26 @@ class MiniWebSocket {
                     const sep = headerBuf.indexOf('\r\n\r\n');
                     if (sep === -1) return;
                     const header = headerBuf.slice(0, sep).toString();
-                    if (!/HTTP\/1\.1 101/.test(header)) return reject(new Error('handshake WS falhou: ' + header.split('\r\n')[0]));
+                    if (!/HTTP\/1\.1 101/.test(header)) return terminar(new Error('handshake WS falhou: ' + header.split('\r\n')[0]));
                     handshaked = true;
                     this.socket = sock;
                     const rest = headerBuf.slice(sep + 4);
                     if (rest.length) this._onData(rest);
-                    resolve();
+                    terminar();
                 } else {
                     this._onData(data);
                 }
             });
             sock.on('error', (err) => {
-                if (!handshaked) reject(err);
+                if (!handshaked) terminar(err);
                 this.closed = true; this.onClose(err);
             });
-            sock.on('close', () => { this.closed = true; this.onClose(); });
+            sock.on('close', () => {
+                // Fechar ANTES do 101 também é falha: sem isto a Promise ficava
+                // pendente quando o Chrome derrubava a conexão calado.
+                if (!handshaked) terminar(new Error('o navegador fechou a conexão antes de aceitar o controle'));
+                this.closed = true; this.onClose();
+            });
         });
     }
     _onData(chunk) {
@@ -322,14 +406,22 @@ async function findOrCreatePageTarget(url) {
     return created;
 }
 
+// Nenhuma etapa do controle de navegador pode pendurar o CLI sem explicação.
+function comTeto(promessa, ms, oQue) {
+    return new Promise((resolve, reject) => {
+        const t = setTimeout(() => reject(new Error(`${oQue} não respondeu em ${Math.round(ms / 1000)}s`)), ms);
+        promessa.then((v) => { clearTimeout(t); resolve(v); }, (e) => { clearTimeout(t); reject(e); });
+    });
+}
+
 async function connect(url) {
     await ensureChromeRunning();
-    const target = await findOrCreatePageTarget(url);
+    const target = await comTeto(findOrCreatePageTarget(url), 15000, 'a lista de abas do navegador');
     if (!target || !target.webSocketDebuggerUrl) throw new Error('Não foi possível obter alvo de página do Chrome.');
     if (currentSession) { try { currentSession.close(); } catch {} }
     currentSession = new CDPSession();
     currentSession.targetId = target.id;
-    await currentSession.attach(target.webSocketDebuggerUrl);
+    await comTeto(currentSession.attach(target.webSocketDebuggerUrl), 12000, 'o canal de controle do navegador');
     await currentSession.send('Page.enable');
     await currentSession.send('DOM.enable');
     await currentSession.send('Runtime.enable');
@@ -403,6 +495,74 @@ async function clickText(text) {
     return { ok: true, ...found };
 }
 
+/**
+ * Espera o seletor aparecer por um instante antes de desistir.
+ *
+ * A página quase sempre ainda está montando quando a próxima ferramenta roda.
+ * Sem esta espera curta, "não encontrado" era muitas vezes "ainda não nasceu".
+ */
+async function esperarSeletor(selector, ms = 4000) {
+    const fim = Date.now() + ms;
+    while (Date.now() < fim) {
+        if (await evaluate(`!!document.querySelector(${JSON.stringify(selector)})`)) return true;
+        await sleep(200);
+    }
+    return false;
+}
+
+/**
+ * O que EXISTE na página, para o erro ensinar em vez de só reclamar.
+ *
+ * Mesma ideia do `trechosParecidos` do edit_file: erro seco faz o modelo chutar de
+ * novo. Devolvendo o que está lá, ele acerta na segunda tentativa.
+ *
+ * Caso real: o modelo pediu `input[name="q"]` no Google. A caixa de busca do
+ * Google é `textarea[name="q"]` — o chute era razoável e estava errado, e o erro
+ * antigo não dava nenhuma pista de qual era o certo.
+ */
+async function candidatosNaPagina() {
+    const js = `(function(){
+        // Ordem importa: quem errou um seletor quase sempre queria um CAMPO, e a
+        // lista é cortada em 12. Link de navegação por último, senão o campo de
+        // busca fica de fora justamente no caso em que ele é a resposta.
+        const porPrioridade = [
+            'input:not([type=hidden]),textarea,[contenteditable],[role=textbox]',
+            'button,[role=button],select,input[type=submit]',
+            'a[href]',
+        ];
+        const alvos = [];
+        for (const grupo of porPrioridade) {
+            for (const e of document.querySelectorAll(grupo)) if (!alvos.includes(e)) alvos.push(e);
+        }
+        const vistos = [];
+        for (const e of alvos) {
+            const r = e.getBoundingClientRect();
+            if (r.width < 2 || r.height < 2) continue;          // invisível não serve
+            const tag = e.tagName.toLowerCase();
+            let sel = tag;
+            if (e.id) sel = tag + '#' + e.id;
+            else if (e.name) sel = tag + '[name="' + e.name + '"]';
+            else if (e.getAttribute('aria-label')) sel = tag + '[aria-label="' + e.getAttribute('aria-label') + '"]';
+            else if (e.type) sel = tag + '[type="' + e.type + '"]';
+            const rotulo = (e.getAttribute('aria-label') || e.placeholder || (e.innerText||'').trim().slice(0,30) || '').replace(/\\s+/g,' ');
+            vistos.push(rotulo ? sel + '  (' + rotulo + ')' : sel);
+            if (vistos.length >= 12) break;
+        }
+        return JSON.stringify(vistos);
+    })()`;
+    try { return JSON.parse(await evaluate(js)) || []; } catch { return []; }
+}
+
+async function erroDeSeletor(selector) {
+    const candidatos = await candidatosNaPagina();
+    const err = new Error(
+        `seletor não encontrado: ${selector}`
+        + (candidatos.length ? `. Existem nesta página: ${candidatos.join(' · ')}` : '. A página não tem nenhum elemento clicável visível — ela pode não ter carregado.')
+    );
+    err.candidatos = candidatos;
+    return err;
+}
+
 async function clickSelector(selector) {
     await ensure();
     const js = `(function(){
@@ -412,8 +572,9 @@ async function clickSelector(selector) {
         const r = el.getBoundingClientRect();
         return { x: r.left + r.width/2, y: r.top + r.height/2, tag: el.tagName };
     })()`;
-    const found = await evaluate(js);
-    if (!found) throw new Error(`seletor não encontrado: ${selector}`);
+    let found = await evaluate(js);
+    if (!found && await esperarSeletor(selector)) found = await evaluate(js);
+    if (!found) throw await erroDeSeletor(selector);
     await sleep(200);
     await click(found.x, found.y);
     return { ok: true, selector, ...found };
@@ -430,14 +591,16 @@ async function type(text) {
 
 async function typeInSelector(selector, text, clear = true) {
     await ensure();
-    const focused = await evaluate(`(function(){
+    const focar = () => evaluate(`(function(){
         const el = document.querySelector(${JSON.stringify(selector)});
         if (!el) return false;
         el.focus();
         ${clear ? "if ('value' in el) el.value = '';" : ''}
         return true;
     })()`);
-    if (!focused) throw new Error(`seletor não encontrado: ${selector}`);
+    let focused = await focar();
+    if (!focused && await esperarSeletor(selector)) focused = await focar();
+    if (!focused) throw await erroDeSeletor(selector);
     await type(text);
     // dispara evento input para frameworks reativos
     await evaluate(`(function(){
@@ -508,5 +671,6 @@ function close() {
 module.exports = {
     open, navigate, click, clickText, clickSelector, type, typeInSelector,
     key, screenshot, evaluate, currentUrl, waitFor, wait, scroll, close,
-    _internal: { findChrome, PROFILE_DIR, DEBUG_PORT },
+    avisoDeLocal,
+    _internal: { findChrome, procurarEmVolumes, PROFILE_DIR, DEBUG_PORT },
 };

package/lib/tools.js

@@ -317,11 +317,41 @@ function writeTodos({ todos }) {
 }
 function getTodos() { return TODOS; }
 
+/**
+ * Executa uma ferramenta e NUNCA lança.
+ *
+ * O `await` aqui não é enfeite. O despachante abaixo faz `return browser.x(...)`
+ * em vinte casos, e `try { return promessa } catch` **não** pega a rejeição dessa
+ * promessa — só `return await` pega. Sem isto, qualquer falha de navegador ou
+ * desktop subia por cima do loop do agente e derrubava o CLI inteiro com exit 1,
+ * em vez de virar uma ação falhada que o modelo pode corrigir.
+ *
+ * Foi exatamente o que acontecia ao pedir uma pesquisa no Google: o seletor não
+ * batia, a promessa rejeitava, e o programa morria calado no meio da tarefa.
+ */
 async function execute(name, args, ctx) {
+    try {
+        return await despachar(name, args, ctx);
+    } catch (e) {
+        // Erro que sabe o que EXISTE leva a informação junto — mesma ideia do
+        // `trechosParecidos` do edit_file. Erro seco faz o modelo chutar de novo.
+        if (e && Array.isArray(e.candidatos) && e.candidatos.length) {
+            return {
+                ok: false,
+                error: e.message,
+                seletoresDisponiveis: e.candidatos,
+                comoCorrigir: 'Chame a tool de novo com um seletor de "seletoresDisponiveis", copiado LITERALMENTE. O primeiro da lista é o mais provável.',
+            };
+        }
+        return { ok: false, error: e.message || String(e) };
+    }
+}
+
+async function despachar(name, args, ctx) {
     const projectDir = (ctx && ctx.projectDir) || process.cwd();
     args = args || {};
 
-    try {
+    {
         switch (name) {
             case 'write_file': {
                 const filePath = resolveInProject(args.path, projectDir);
@@ -410,8 +440,6 @@ async function execute(name, args, ctx) {
             default:
                 return { ok: false, error: `Tool não implementada: ${name}` };
         }
-    } catch (e) {
-        return { ok: false, error: e.message };
     }
 }
 

package/lib/ui.js

@@ -163,7 +163,7 @@ const TIPS = [
 const NEWS = [
     'Modelos grátis, com reserva: um no limite não vira erro na sua tela',
     'Ele trabalha em ~/primocode. Fale o nome de uma pasta e ele muda sozinho',
-    '/tudo lista as 30 ferramentas que ele sabe usar',
+    'Falha de navegador agora diz quais seletores EXISTEM na página',
 ];
 
 // ── Cabeçalho ────────────────────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "7.8.0",
+  "version": "7.9.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Modelos grátis. Cria arquivos, roda comandos, controla navegador e desktop.",
   "main": "bin/primocode.js",
   "bin": {