primocode 11.0.0 → 11.2.0

package/lib/permission/sandbox.js

@@ -0,0 +1,252 @@
+/**
+ * sandbox.js — a cerca em volta do run_shell.
+ *
+ * Decisão do Joel (08/10, JOEL-FEAT-002): isolamento NATIVO, leve, sem VM.
+ *   macOS  → sandbox-exec (Seatbelt) com um perfil gerado na hora
+ *   Linux  → bubblewrap (bwrap), se existir
+ *   Windows/sem mecanismo → best_effort (avisa uma vez e segue) ou
+ *                           hard_requirement (recusa)
+ *
+ * O que o comando pode: escrever na pasta do projeto, em /tmp e em
+ * ~/.primocode/cache; ler quase tudo, MENOS os arquivos de credencial da
+ * LEITURA_NEGADA_HOME (chaves, tokens, a conta do PrimoCode, o Keychain) e
+ * .env*. Rede ligada (o `npm install` precisa), com opção de cortar.
+ * No macOS ainda fica de fora: osascript, o comando `security` (Keychain) e
+ * escrever hook em .git/hooks (rodaria FORA da cerca no próximo commit).
+ * O ssh-agent da pessoa fica fora por padrão (review do Arthur, #162): sem
+ * ele, "não lê ~/.ssh" vale de verdade, e não só para o arquivo.
+ * Quando bloqueia, a mensagem diz POR QUE, para o modelo aprender.
+ *
+ * Config em ~/.primocode/config.json:
+ *   "sandbox": { "ligado": true, "modo": "best_effort"|"hard_requirement",
+ *                "rede": true, "ssh_agent": false, "env_permitidas": ["MINHA_KEY"],
+ *                "escrita_extra": ["~/.npm"] }
+ */
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFile, spawnSync } = require('child_process');
+
+const MODOS = ['best_effort', 'hard_requirement'];
+const LEITURA_NEGADA_HOME = ['.ssh', '.aws', '.config/gcloud', '.npmrc',
+    '.primocode/conta.json', '.netrc', '.git-credentials', '.config/gh', '.docker', '.kube', 'Library/Keychains',
+    '.config/git/credentials', '.pypirc', '.gnupg', '.cargo/credentials', '.cargo/credentials.toml'];
+// Socket do ssh-agent do macOS (launchd). O caminho exato vem do SSH_AUTH_SOCK; a regex pega os outros.
+const SOCKET_SSH_MAC = '^/private/(tmp|var/run)/com\\.apple\\.launchd\\.[^/]+/Listeners$';
+const SECRETA = /(_KEY|_TOKEN|SECRET)/i;
+
+let _avisou = false;
+let _avisouDesligado = false;
+let _forcaMecanismo; // teste: undefined = detectar; null = ausente; 'seatbelt'|'bwrap'
+
+function arquivoConfig(home) { return path.join(home || os.homedir(), '.primocode', 'config.json'); }
+
+function lerConfig(home) {
+    try { return JSON.parse(fs.readFileSync(arquivoConfig(home), 'utf8')) || {}; } catch { return {}; }
+}
+
+function config(home) {
+    const s = lerConfig(home).sandbox || {};
+    return {
+        ligado: typeof s.ligado === 'boolean' ? s.ligado : process.platform === 'darwin',
+        modo: MODOS.includes(s.modo) ? s.modo : 'best_effort',
+        rede: s.rede !== false,
+        ssh_agent: s.ssh_agent === true,
+        env_permitidas: Array.isArray(s.env_permitidas) ? s.env_permitidas.map(String) : [],
+        escrita_extra: Array.isArray(s.escrita_extra) ? s.escrita_extra.map(String) : [],
+    };
+}
+
+function salvar(parcial, home) {
+    const arq = arquivoConfig(home);
+    const atual = lerConfig(home);
+    atual.sandbox = { ...(atual.sandbox || {}), ...parcial };
+    fs.mkdirSync(path.dirname(arq), { recursive: true });
+    fs.writeFileSync(arq, JSON.stringify(atual, null, 2));
+    return config(home);
+}
+
+function temBinario(nome) {
+    try { return spawnSync(nome, ['--version'], { stdio: 'ignore', timeout: 3000 }).error === undefined; } catch { return false; }
+}
+
+function mecanismo() {
+    if (_forcaMecanismo !== undefined) return _forcaMecanismo;
+    if (process.platform === 'darwin') return fs.existsSync('/usr/bin/sandbox-exec') ? 'seatbelt' : null;
+    if (process.platform === 'linux') return temBinario('bwrap') ? 'bwrap' : null;
+    return null;
+}
+
+/** Linha para a PESSOA ver no terminal (o stderr do comando só o modelo lê). Vai pro
+ *  stderr do processo para não sujar a saída do `-p`. */
+function avisarPessoa(msg) {
+    try { console.error(require('../tui/ui.js').c.warn(`  ⎿ ${msg}`)); } catch { /* sem tela */ }
+}
+
+function socketSsh() {
+    const s = process.env.SSH_AUTH_SOCK;
+    try { return s && fs.statSync(s).isSocket() ? real(s) : null; } catch { return null; }
+}
+
+function real(p) { try { return fs.realpathSync(p); } catch { return path.resolve(p); } }
+function expandir(p, home) { return p.startsWith('~') ? path.join(home, p.slice(1)) : p; }
+const sbq = (s) => '"' + String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"';
+
+function caminhos(projectDir, cfg, home) {
+    const escrita = [real(projectDir), '/tmp', real('/tmp'), real(os.tmpdir()), path.join(home, '.primocode', 'cache'),
+        ...cfg.escrita_extra.map((p) => expandir(p, home))];
+    try { fs.mkdirSync(path.join(home, '.primocode', 'cache'), { recursive: true }); } catch { /* sem cache, sem drama */ }
+    const negadosLeitura = LEITURA_NEGADA_HOME.map((p) => path.join(home, p));
+    return { escrita: [...new Set(escrita.map((p) => real(p)))], negadosLeitura };
+}
+
+/** Perfil Seatbelt. Em Seatbelt a ÚLTIMA regra que casa vence: negações no fim. */
+function perfilSeatbelt(projectDir, cfg = config(), home = os.homedir()) {
+    const { escrita, negadosLeitura } = caminhos(projectDir, cfg, home);
+    const l = ['(version 1)', '(allow default)', '(deny file-write*)'];
+    for (const p of escrita) l.push(`(allow file-write* (subpath ${sbq(p)}))`);
+    l.push('(allow file-write* (literal "/dev/null") (literal "/dev/tty") (literal "/dev/dtracehelper") (regex #"^/dev/fd/"))');
+    // Hook em .git/hooks roda fora da cerca no próximo `git commit` da pessoa. O .sample do `git init` passa.
+    l.push('(deny file-write* (regex #"/\\.git/hooks/[^/]+$"))');
+    // A pasta em si também: sem `rm -rf .git/hooks && mv pasta-minha .git/hooks`, nem `mv .git` pra recriar.
+    // Só unlink/rename (não create): o `git init` precisa criar a pasta hooks.
+    l.push('(deny file-write-unlink (regex #"/\\.git/hooks$"))');
+    l.push('(deny file-write-unlink (regex #"/\\.git$"))');
+    l.push('(allow file-write* (regex #"/\\.git/hooks/[^/]+\\.sample$"))');
+    for (const p of negadosLeitura) l.push(`(deny file-read* (subpath ${sbq(real(p))}) (subpath ${sbq(p)}))`);
+    l.push('(deny file-read* (regex #"/\\.env($|\\.[^/]*$)"))');
+    // osascript manda o Terminal/Finder fazer o que a cerca não deixa; `security` lê o Keychain.
+    l.push('(deny process-exec (literal "/usr/bin/osascript") (literal "/usr/bin/security"))');
+    l.push('(deny appleevent-send)');
+    l.push('(deny mach-lookup (global-name "com.apple.SecurityServer") (global-name "com.apple.securityd"))');
+    if (!cfg.ssh_agent) {
+        const sock = socketSsh();
+        l.push(`(deny network-outbound (remote unix-socket (path-regex #"${SOCKET_SSH_MAC}")))`);
+        if (sock) l.push(`(deny network-outbound (remote unix-socket (path-literal ${sbq(sock)})))`);
+    }
+    if (!cfg.rede) l.push('(deny network*)');
+    return l.join('\n');
+}
+
+function argsBwrap(projectDir, cfg = config(), home = os.homedir()) {
+    const { escrita, negadosLeitura } = caminhos(projectDir, cfg, home);
+    const a = ['--ro-bind', '/', '/', '--dev', '/dev', '--proc', '/proc'];
+    for (const p of escrita) if (fs.existsSync(p)) a.push('--bind', p, p);
+    for (const p of negadosLeitura) {
+        if (!fs.existsSync(p)) continue;
+        if (fs.statSync(p).isDirectory()) a.push('--tmpfs', p); else a.push('--ro-bind', '/dev/null', p);
+    }
+    // .env* na pasta do projeto (um nível; o resto o Seatbelt cobre por regex)
+    try {
+        for (const f of fs.readdirSync(projectDir)) {
+            if (/^\.env($|\.)/.test(f)) a.push('--ro-bind', '/dev/null', path.join(real(projectDir), f));
+        }
+    } catch { /* pasta sumiu */ }
+    // Montado DEPOIS do --bind do projeto, para valer por cima dele. [VERIFICAR] no Linux.
+    const hooks = path.join(real(projectDir), '.git', 'hooks');
+    if (fs.existsSync(hooks)) a.push('--ro-bind', hooks, hooks);
+    const sock = cfg.ssh_agent ? null : socketSsh();
+    if (sock) a.push('--ro-bind', '/dev/null', sock);
+    if (!cfg.rede) a.push('--unshare-net');
+    a.push('--die-with-parent', '--chdir', real(projectDir));
+    return a;
+}
+
+/** Decide como envolver o comando. Devolve { cmd, args } ou { recusado } ou { semCerca }. */
+function envolver(command, projectDir, opts = {}) {
+    const home = opts.home || os.homedir();
+    const cfg = opts.cfg || config(home);
+    if (!cfg.ligado) {
+        let aviso = null;
+        if (!_avisouDesligado) {
+            _avisouDesligado = true;
+            aviso = process.platform === 'darwin'
+                ? 'aviso: o sandbox está desligado; os comandos do agente rodam sem cerca. /sandbox on liga.'
+                : 'aviso: o sandbox vem desligado fora do macOS; os comandos do agente rodam sem cerca. /sandbox on liga (no Linux precisa do bwrap).';
+        }
+        return { semCerca: true, motivo: 'desligado', aviso };
+    }
+    const mec = mecanismo();
+    if (!mec) {
+        if (cfg.modo === 'hard_requirement') {
+            return { recusado: 'o sandbox está em hard_requirement e este computador não tem como isolar (macOS: sandbox-exec; Linux: bwrap). Comando não rodou. Instale o bwrap ou use /sandbox off.' };
+        }
+        let aviso = null;
+        if (!_avisou) { _avisou = true; aviso = 'aviso: sem sandbox neste computador (modo best_effort); o comando roda sem isolamento.'; }
+        return { semCerca: true, motivo: 'sem_mecanismo', aviso };
+    }
+    if (mec === 'seatbelt') return { cmd: '/usr/bin/sandbox-exec', args: ['-p', perfilSeatbelt(projectDir, cfg, home), '/bin/sh', '-c', command], mec, cfg, home };
+    return { cmd: 'bwrap', args: [...argsBwrap(projectDir, cfg, home), '/bin/sh', '-c', command], mec, cfg, home };
+}
+
+/** Se o comando falhou por causa da cerca, diz por quê (e qual caminho). */
+function explicar(stderr, projectDir, cfg, home) {
+    const txt = String(stderr || '');
+    const m = /(?:^|\n)(?:[^\n:]*:\s*)?(\/[^\n:]+?|\.{1,2}\/[^\n:]+?|[^\s:'"]+?):?\s*(?:(?:open|read|stat|lstat|opendir|write):\s*)?(?:Operation not permitted|Permission denied|Read-only file system)/.exec(txt)
+        || /(?:Operation not permitted|Permission denied|Read-only file system)[^\n]*?['"]([^'"\n]+)['"]/.exec(txt);
+    if (!m) return null;
+    const alvo = path.resolve(projectDir, m[1].trim());
+    const { negadosLeitura } = caminhos(projectDir, cfg, home);
+    const secreto = negadosLeitura.some((p) => alvo === p || alvo.startsWith(p + path.sep) || alvo.startsWith(real(p) + path.sep))
+        || /(^|\/)\.env($|\.)/.test(alvo);
+    if (secreto) return `o sandbox bloqueou leitura de segredo: ${alvo} (${LEITURA_NEGADA_HOME.map((p) => '~/' + p).join(', ')} e .env* ficam fora do alcance). Não tente ler isso; peça ao usuário o que precisa.`;
+    if (/\/\.git\/hooks\//.test(alvo)) return `o sandbox bloqueou escrita em hook do git: ${alvo}. Hook roda fora da cerca; se o usuário quiser um, ele instala.`;
+    if (/Read-only|Operation not permitted|Permission denied/.test(txt)) {
+        return `o sandbox bloqueou escrita fora do projeto: ${alvo}. Escreva só dentro de ${projectDir}, em /tmp ou em ~/.primocode/cache.`;
+    }
+    return null;
+}
+
+function filtrarEnv(env, permitidas) {
+    const out = {};
+    for (const [k, v] of Object.entries(env)) {
+        if (v === undefined) continue;
+        if (SECRETA.test(k) && !permitidas.includes(k)) continue;
+        out[k] = v;
+    }
+    return out;
+}
+
+/** Roda o comando dentro da cerca. Mesmo formato do runShell: { ok, code, stdout, stderr }. */
+function executar(command, { projectDir, timeout = 60000, env = process.env, home, homeProtegido } = {}) {
+    const cwd = projectDir || process.cwd();
+    const cfg = config(home);
+    const env2 = filtrarEnv(env, cfg.env_permitidas);
+    // `home` só escolhe de onde lê a config; as pastas protegidas são as do ~ de verdade (`homeProtegido` é para teste).
+    const e = envolver(command, cwd, { cfg, home: homeProtegido });
+    // Sem .git/hooks (git init --template=), um `mv` criaria a pasta lá dentro. Criada aqui, fora da cerca, o unlink barra a troca.
+    try { if (fs.statSync(path.join(cwd, '.git')).isDirectory()) fs.mkdirSync(path.join(cwd, '.git', 'hooks'), { recursive: true }); } catch { /* sem .git: nada a proteger */ }
+    return new Promise((resolve) => {
+        if (e.recusado) return resolve({ ok: false, code: 126, stdout: '', stderr: e.recusado, sandbox: { recusado: true } });
+        const termina = (error, stdout, stderr) => {
+            let err = stderr || '';
+            const info = { mecanismo: e.mec || null };
+            if (e.aviso) { err = e.aviso + '\n' + err; avisarPessoa(e.aviso); }
+            if (error && e.mec) {
+                const why = explicar(err, cwd, cfg, e.home);
+                if (why) { err = err + '\n[sandbox] ' + why; info.bloqueou = why; }
+            }
+            const r = error ? { ok: false, code: error.code ?? 1, stdout, stderr: err, killed: error.killed } : { ok: true, code: 0, stdout, stderr: err };
+            r.sandbox = info;
+            resolve(r);
+        };
+        const opt = { timeout, cwd, maxBuffer: 10 * 1024 * 1024, env: env2 };
+        if (e.semCerca) return require('child_process').exec(command, opt, termina);
+        execFile(e.cmd, e.args, opt, termina);
+    });
+}
+
+function estado(home) {
+    const cfg = config(home);
+    const mec = mecanismo();
+    return { ...cfg, mecanismo: mec, ativo: cfg.ligado && !!mec };
+}
+
+function _teste({ mecanismo: m, avisou } = {}) {
+    if (m !== undefined) _forcaMecanismo = m === 'auto' ? undefined : m;
+    if (avisou !== undefined) { _avisou = avisou; _avisouDesligado = avisou; }
+}
+
+module.exports = { config, salvar, estado, mecanismo, envolver, executar, explicar, filtrarEnv, perfilSeatbelt, argsBwrap, MODOS, _teste };

package/lib/piloto.js

@@ -0,0 +1,39 @@
+// Piloto automático (docs/estrutura.md, seção 9): os agentes ligados procuram o que fazer e fazem.
+// Este módulo só decide QUEM roda e QUANDO parar; quem executa é injetado (o app-server passa o motor).
+// Node puro. Um ciclo roda os agentes ligados um de cada vez e para no freio da cota.
+'use strict';
+
+/* O que o agente recebe quando ninguém pediu nada: procurar trabalho no seu terreno. */
+function pedidoDoPiloto(agente, { grupo = false } = {}) {
+    return `[piloto automático] Você é @${agente.nome}. Procure UMA coisa útil para fazer no seu terreno `
+        + `(${agente.onde && agente.onde !== 'fora' ? `projeto ${agente.onde}` : 'fora de projetos'}) e faça. `
+        + 'Tudo que escrever arquivo vai para a pessoa aprovar antes de valer. Se não houver nada a fazer, diga isso em uma frase.'
+        + (grupo ? ' Se precisar de outro agente ligado, chame com spawn_agent (profundidade 1).' : '');
+}
+
+/* Freio padrão: a cota do plano (lib/limites.js). Sem rede vale o modo local generoso. */
+async function freioDaCota() {
+    try {
+        const c = await require('./config/limites').situacao();
+        if (c && (c.ok === false || c.liberado === false || c.restam === 0)) return { parar: true, motivo: 'a cota do plano acabou' };
+    } catch { /* sem leitura, não barra */ }
+    return { parar: false };
+}
+
+/* `ciclo({ agentes, executar, freio, ocupado, grupo })` → { executados:[{agente,ok,resumo}], parou? }.
+   `executar(agente, pedido)` devolve o resumo (texto) ou lança. */
+async function ciclo({ agentes = [], executar, freio = freioDaCota, ocupado = () => false, grupo = false } = {}) {
+    const ligados = agentes.filter((a) => a.ligado);
+    const r = { executados: [], parou: null };
+    if (!ligados.length) { r.parou = 'nenhum agente ligado'; return r; }
+    for (const a of ligados) {
+        if (ocupado()) { r.parou = 'a pessoa está trabalhando'; break; }
+        const f = await freio();
+        if (f && f.parar) { r.parou = f.motivo || 'freio'; break; }
+        try { r.executados.push({ agente: a.nome, ok: true, resumo: String(await executar(a, pedidoDoPiloto(a, { grupo })) || '').slice(0, 400) }); }
+        catch (e) { r.executados.push({ agente: a.nome, ok: false, resumo: (e && e.message) || 'falhou' }); }
+    }
+    return r;
+}
+
+module.exports = { ciclo, pedidoDoPiloto, freioDaCota };

package/lib/placar.js

@@ -133,7 +133,7 @@ function veredito(s = {}, concluiu) {
     return null;
 }
 
-/** Fecha uma tarefa: grava o desfecho. Vem do runAct (lib/act.js). */
+/** Fecha uma tarefa: grava o desfecho. Vem do runAct (lib/session/runner/act.js). */
 function fechar(tipo, sinais, concluiu, home) {
     const v = veredito(sinais, concluiu);
     if (v === null) return null;

package/lib/plano-previo.js

@@ -6,7 +6,7 @@
  *   resposta(texto, passos)          → { acao: 'comecar' | 'cancelar' | 'editar' | 'invalida', n? }   (puro)
  *   comoPassos(pedido, passos)       → [{ titulo, pedido }] no formato do enviarPedido        (puro)
  *
- * Nada de planejador novo: a 1ª fase usa o modo "plano" de lib/perigo.js (recusa escrita), e a 2ª entrega os passos
+ * Nada de planejador novo: a 1ª fase usa o modo "plano" de lib/permission/perigo.js (recusa escrita), e a 2ª entrega os passos
  * aprovados ao laço de passos que o enviarPedido já tem (checkpoint do pedido inteiro, fatos passados de um passo
  * pro outro, retomada). Quem não programa não precisa saber disso: vê 3 a 5 frases e aperta Enter.
  */

package/lib/plugin/auto-preview.js

@@ -0,0 +1,71 @@
+/**
+ * auto-preview.js — quando o agente sobe um servidor de dev (run_background: npm run dev, vite, next dev,
+ * python -m http.server…), espera o endereço aparecer na saída e ABRE o app no navegador, já com o overlay
+ * de edição visual (botão "✎ Editar", lib/plugin/edicao-visual.js) — sem a pessoa pedir.
+ *
+ * Só abre com terminal de verdade (ctx.escolher existe) ou PRIMOCODE_PREVIEW_AUTO=1; nunca em -p, voz ou
+ * subagente. PRIMOCODE_SEM_PREVIEW=1 desliga. Uma vez por endereço. Sem dependência nova.
+ */
+'use strict';
+
+const path = require('path');
+
+const RE_DEV = /\b(npm|pnpm|yarn|bun)\s+(run\s+)?(dev|start|serve|preview)\b|\b(vite|next\s+dev|nuxt\s+dev|astro\s+dev|remix\s+dev|webpack(-dev-server|\s+serve)|parcel|live-server|http-server|serve)\b|python3?\s+-m\s+http\.server|flask\s+run|uvicorn|rails\s+s(erver)?\b|php\s+-S/i;
+const abertos = new Map();   // url real → { urlAberta, proxy }
+
+function ehServidorDev(comando) { return RE_DEV.test(String(comando || '')); }
+
+function ativo(ctx) {
+    if (process.env.PRIMOCODE_SEM_PREVIEW === '1') return false;
+    return process.env.PRIMOCODE_PREVIEW_AUTO === '1' || !!(ctx && typeof ctx.escolher === 'function');
+}
+
+const dormir = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/**
+ * Espera o endereço do servidor `id` e abre. Devolve { url, visual?, aberto } ou null (sem endereço a tempo / desligado).
+ * deps (testes): fundo, abrir(url), proxiar(alvo, porta, opcoes), portaLivre(), espera, aoEditar(pedido)
+ */
+async function abrirQuandoPronto(id, ctx = {}, deps = {}) {
+    if (!deps.forcar && !ativo(ctx)) return null;
+    const fundo = deps.fundo || require('../fundo');
+    const espera = deps.espera == null ? 20000 : deps.espera;
+    let url = null;
+    for (const fim = Date.now() + espera; Date.now() < fim && !url;) {
+        const s = fundo.saida(id);
+        if (!s || s.ok === false) return null;
+        url = fundo.endereco(s.texto);
+        if (!url && ctx.comando) {   // servidor que não imprime o endereço (ou imprime em buffer): a porta que está no comando
+            const m = String(ctx.comando).match(/(?:--port[ =]|-p\s+|PORT=|http\.server\s+|runserver\s+|:)(\d{2,5})\b/);
+            if (m && await (deps.responde || require('./preview.js').responde)(`http://localhost:${m[1]}`)) url = `http://localhost:${m[1]}`;
+        }
+        if (!url) { if (s.rodando === false) return null; await dormir(deps.intervalo || 300); }
+    }
+    if (!url) return null;
+    if (abertos.has(url)) return { url, ...abertos.get(url), jaAberto: true };
+    const dir = ctx.projectDir || process.cwd();
+    const V = require('./edicao-visual.js');
+    const P = require('./preview.js');
+    let alvo = url, proxy = null;
+    try {
+        const porta = await (deps.portaLivre || P.portaLivre)();
+        const aoEditar = deps.aoEditar || ctx.aoEditar || (async (pedido) => {
+            const { sh } = require('../cli/util.js');
+            sh(process.execPath, [path.join(__dirname, '..', '..', 'bin', 'primocode.js'), '-p', pedido], { cwd: dir });
+        });
+        proxy = await (deps.proxiar || V.proxiar)(url, porta, { dir, aoEditar });
+        if (proxy && proxy.unref) proxy.unref();
+        alvo = `http://localhost:${porta}`;
+    } catch { alvo = url; proxy = null; }   // sem proxy abre o app puro: melhor que não abrir
+    const abrir = deps.abrir || ((u) => require('../tool/tools').openInBrowser(u));
+    const r = await abrir(alvo);
+    const aberto = !r || r.ok !== false;
+    const info = { urlAberta: alvo, visual: alvo !== url, aberto };
+    if (aberto) abertos.set(url, info);
+    else if (proxy) try { proxy.close(); } catch { /* */ }
+    return { url, ...info };
+}
+
+function esquecer() { abertos.clear(); }
+
+module.exports = { ehServidorDev, abrirQuandoPronto, ativo, esquecer, RE_DEV };

package/lib/plugin/autoteste.js

@@ -20,6 +20,7 @@ const MAX_RODADAS = 2;
 const COLETOR = `(function(){ if (window.__primoErros) return 1; window.__primoErros = [];
   window.addEventListener('error', function(e){ window.__primoErros.push('erro: ' + (e.message || e)); });
   window.addEventListener('unhandledrejection', function(e){ window.__primoErros.push('promessa sem catch: ' + ((e.reason && e.reason.message) || e.reason)); });
+  window.alert = function(){}; window.confirm = function(){ return true; }; window.prompt = function(){ return ''; };  // diálogo travaria o navegador
   var ce = console.error; console.error = function(){ window.__primoErros.push('console.error: ' + Array.prototype.slice.call(arguments).join(' ')); ce.apply(console, arguments); };
   return 1; })()`;