primocode 9.9.0 → 10.0.0

package/lib/app.js

@@ -1,615 +0,0 @@
-/**
- * app.js — o PrimoCode como aplicativo de janela.
- *
- *   "Se mandar /app pra ele, ele abre o aplicativo que você vai desenvolver
- *    para o Mac e o Windows, já instala junto com o npm. Vai ser um aplicativo
- *    desktop bem bonito com as cores do PrimoCode, com aquele azul. Bem estilo
- *    Codex. Vai ter o chat em localhost. Um chat estilo terminal para quem não
- *    quer o terminal."
- *
- * ── POR QUE NÃO É ELECTRON ───────────────────────────────────────────────
- * O PrimoCode tem ZERO dependência de npm, e isso não é purismo: é o que faz
- * `npm i -g primocode` levar segundos em vez de baixar 200 MB de navegador
- * empacotado. Electron levaria os dois embora — a promessa de "já instala
- * junto com o npm" e a instalação leve.
- *
- * O que Electron entrega, no fundo, é uma janela sem barra de endereço
- * mostrando uma página local. Chrome, Edge e Brave fazem exatamente isso com
- * `--app=<url>`: janela limpa, ícone próprio na barra de tarefas, sem abas.
- * O navegador já está na máquina do usuário — no Windows o Edge vem com o
- * sistema, no Mac o Safari (e quase sempre o Chrome).
- *
- * Então: servidor HTTP local (http do Node, nada instalado) + janela do
- * navegador em modo app. Se não houver nenhum navegador de Chromium, abre
- * numa aba normal, que continua funcionando.
- *
- * ── O LAYOUT: CHAT, NÃO TERMINAL ─────────────────────────────────────────
- * "Remove a IDE ou deixa idêntico ao Codex." A janela é um chat de app de
- * mesa: barra lateral (novo chat, projetos, recentes), a pergunta no meio da
- * tela vazia e o compositor embaixo com projeto, anexo, permissão, esforço e
- * voz. A conversa aparece como chat — o pedido num balão, a fala do Primo em
- * texto e cada ação dele numa linha cinza ("Editou style.css +12 −3").
- *
- * Essas linhas NÃO saem de reler a saída colorida do terminal: vêm do canal
- * estruturado de lib/fala.js, que é quem desenha o terminal. Uma verdade só,
- * duas telas. O terminal continua espelhado (`process.stdout.write`
- * duplicado) e fica atrás do botão "Terminal" — quem quiser o detalhe cru
- * ainda tem.
- *
- * ── SEGURANÇA ────────────────────────────────────────────────────────────
- * Este servidor MANDA NO AGENTE: quem fala com ele executa comando, escreve
- * arquivo e gasta a cota do usuário. Por isso ele só escuta em 127.0.0.1 e
- * exige uma chave sorteada a cada abertura — sem ela, uma página qualquer
- * aberta no mesmo navegador dispararia pedidos para cá.
- */
-
-'use strict';
-
-const http = require('http');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const crypto = require('crypto');
-const { execFile } = require('child_process');
-const fala = require('./fala.js');
-const cfg = require('./config.js');
-const perigo = require('./perigo.js');
-const effort = require('./effort.js');
-const extra = require('./comandos-extra.js');
-
-const WEB = path.join(__dirname, '..', 'app');
-const PORTA_PADRAO = Number(process.env.PRIMOCODE_APP_PORT) || 7788;
-
-// ── espelho da saída ─────────────────────────────────────────────────────
-
-/* Duplica tudo que vai para o terminal, sem tirar nada de lá.
- *
- * O `write` original continua sendo chamado com os mesmos argumentos e o mesmo
- * retorno: se este espelho mudasse o valor de volta, o Node passaria a achar
- * que o buffer encheu (ou que não encheu) e a saída sairia picada. */
-function espelhar(aoEscrever) {
-    const real = process.stdout.write.bind(process.stdout);
-    process.stdout.write = function (pedaco, enc, cb) {
-        try {
-            aoEscrever(typeof pedaco === 'string' ? pedaco : Buffer.from(pedaco).toString('utf8'));
-        } catch { /* o espelho nunca pode derrubar a saída */ }
-        return real(pedaco, enc, cb);
-    };
-    return function parar() { process.stdout.write = real; };
-}
-
-/* O prompt do readline e os quadros do rodinha não são conteúdo: são a
-   interface do TERMINAL se redesenhando. Na página eles viravam lixo piscando
-   no meio da conversa. O jeito de reconhecê-los é o que sobra depois de tirar
-   o ANSI: pedaço curto e sem quebra de linha é desenho, não texto. */
-function ehRuido(texto) {
-    const limpo = texto.replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '').replace(/\r/g, '');
-    if (limpo.includes('\n')) return false;
-    return limpo.trim().length < 12;
-}
-
-// ── o servidor ───────────────────────────────────────────────────────────
-
-function tipoDe(arquivo) {
-    if (arquivo.endsWith('.html')) return 'text/html; charset=utf-8';
-    if (arquivo.endsWith('.css')) return 'text/css; charset=utf-8';
-    if (arquivo.endsWith('.js')) return 'application/javascript; charset=utf-8';
-    if (arquivo.endsWith('.svg')) return 'image/svg+xml';
-    return 'application/octet-stream';
-}
-
-/* O anexo que chega pela janela vira `state.attachedFiles`, igual ao
-   /attach — e o /attach lê como TEXTO. Um PNG lido como texto entraria no
-   pedido como lixo e gastaria a cota inteira do modelo, então binário é
-   recusado aqui, com o motivo. 2 MB é o teto: acima disso o texto sozinho já
-   estoura o contexto de qualquer modelo grátis. */
-const MAX_ANEXO = 2 * 1024 * 1024;
-
-/* "Recentes" sem conta: os últimos pedidos do history.jsonl, o mesmo arquivo
-   que o /historico procura. Lê só o fim do arquivo — ele cresce para sempre,
-   e a barra lateral só mostra uns vinte. */
-function recentesLocais(arquivo, limite = 20) {
-    let texto = '';
-    try {
-        const fd = fs.openSync(arquivo, 'r');
-        try {
-            const tam = fs.fstatSync(fd).size;
-            const ler = Math.min(tam, 128 * 1024);
-            const buf = Buffer.alloc(ler);
-            fs.readSync(fd, buf, 0, ler, tam - ler);
-            texto = buf.toString('utf8');
-        } finally { fs.closeSync(fd); }
-    } catch { return []; }
-    const vistos = new Set();
-    const fora = [];
-    const linhas = texto.split('\n').filter(Boolean).reverse();
-    for (const l of linhas) {
-        let j;
-        try { j = JSON.parse(l); } catch { continue; }       // a 1ª linha pode vir cortada
-        const titulo = String(j.prompt || '').replace(/\s+/g, ' ').trim();
-        if (!titulo || titulo.startsWith('/') || vistos.has(titulo)) continue;
-        vistos.add(titulo);
-        fora.push({ titulo: titulo.slice(0, 200), quando: j.ts || null, projeto: j.project || null });
-        if (fora.length >= limite) break;
-    }
-    return fora;
-}
-
-function lerJson(req, max = 64 * 1024) {
-    return new Promise((ok) => {
-        let corpo = '';
-        let grande = false;
-        req.on('data', (c) => {
-            if (grande) return;
-            corpo += c;
-            if (corpo.length > max) { grande = true; }
-        });
-        req.on('end', () => {
-            if (grande) return ok({ __grande: true });
-            try { ok(JSON.parse(corpo || '{}') || {}); } catch { ok(null); }
-        });
-        req.on('error', () => ok(null));
-    });
-}
-
-/**
- * Sobe a janela do PrimoCode.
- *
- * As ações da barra lateral e do compositor (projeto, permissão, esforço,
- * anexo, voz, novo chat) chegam por funções próprias em vez de virar texto de
- * comando: um "/permissoes livre" digitado pela janela entraria na conversa
- * como se a pessoa tivesse escrito. Quem não passar a função cai no comando
- * equivalente via `op.barra` — o teste e o `primo --app` antigo seguem de pé.
- *
- * @param {object} op
- * @param {(texto:string)=>Promise} op.enviar      manda um pedido ao agente
- * @param {(texto:string)=>Promise} op.barra       trata um comando /barra
- * @param {()=>void}                op.interromper para o que estiver rodando
- * @param {()=>object}              op.estado      { pasta, projeto, modo, esforco, permissoes, voz, usuario, mascote, anexos }
- * @param {string}                  op.versao
- * @param {()=>string}              [op.pastaProjeto] liga o painel (Prévia/Arquivos) nesta pasta
- * @param {()=>Array}               [op.projetos]      a lista de ~/primocode (padrão: listarProjetos)
- * @param {(dir:string)=>any}       [op.entrarProjeto]
- * @param {()=>any}                 [op.novoChat]
- * @param {(m:string)=>any}         [op.mudarPermissoes]
- * @param {(n:string)=>any}         [op.mudarEsforco]
- * @param {(f:{path,content})=>any} [op.anexar]
- * @param {(nome?:string)=>any}     [op.desanexar]
- * @param {(ligar:boolean)=>any}    [op.voz]
- * @param {(c:{id,titulo})=>Promise} [op.continuarConversa]
- * @param {'rc'|'ide'}              [op.abrirEm]      'ide' abre com o painel da prévia aberto
- * @param {boolean}                 [op.semJanela]    só o servidor, sem abrir navegador
- */
-async function abrir(op) {
-    const chave = crypto.randomBytes(16).toString('hex');
-    const ouvintes = new Set();
-    let ocupado = false;
-    const fila = [];
-
-    // O histórico do TERMINAL para quem abrir a janela depois — é o que o
-    // botão "Terminal" mostra.
-    const memoria = [];
-    const MEMORIA_MAX = 400;
-    // O histórico do CHAT: o mesmo tipo de coisa, mas já estruturado (pedido,
-    // fala, ação, resultado). Sem ele, um F5 no meio de uma tarefa apagava a
-    // conversa da tela.
-    let conversa = [];
-    const CONVERSA_MAX = 800;
-
-    function emitir(evento, dados) {
-        const linha = `event: ${evento}\ndata: ${JSON.stringify(dados)}\n\n`;
-        for (const res of ouvintes) {
-            try { res.write(linha); } catch { ouvintes.delete(res); }
-        }
-    }
-    function emitirChat(evento, dados) {
-        conversa.push({ evento, dados });
-        if (conversa.length > CONVERSA_MAX) conversa.shift();
-        emitir(evento, dados);
-    }
-    const estadoAgora = () => Object.assign({ versao: op.versao, ocupado }, op.estado());
-
-    const painel = op.pastaProjeto
-        ? require('./painel.js').montar({ pasta: op.pastaProjeto, emitir: (e, d) => emitir(e, d) })
-        : null;
-
-    /* O que o agente faz chega estruturado por lib/fala.js. `falouNesta`
-       diz se o pedido atual produziu alguma coisa por ali: um /help, um
-       /status, não produz — e aí a janela mostra o texto que ele imprimiu. */
-    let falouNesta = false;
-    const aoFalar = (e) => { falouNesta = true; emitirChat('agente', e); };
-    fala.eventos.on('evento', aoFalar);
-
-    let capturando = null;
-    const pararEspelho = espelhar((pedaco) => {
-        if (capturando) capturando.push(pedaco);
-        if (ehRuido(pedaco)) return;
-        memoria.push(pedaco);
-        if (memoria.length > MEMORIA_MAX) memoria.shift();
-        emitir('saida', pedaco);
-    });
-
-    async function processar(texto) {
-        fila.push(texto);
-        if (ocupado) return;
-        ocupado = true;
-        emitir('ocupado', true);
-        while (fila.length) {
-            const t = String(fila.shift() || '').trim();
-            if (!t) continue;
-            emitirChat('voce', t);
-            falouNesta = false;
-            capturando = [];
-            try {
-                if (t.startsWith('/')) await op.barra(t);
-                else await op.enviar(t);
-            } catch (e) {
-                emitirChat('erro', (e && e.message) || String(e));
-            }
-            const impresso = capturando.join('');
-            capturando = null;
-            if (!falouNesta && impresso.replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '').trim()) {
-                emitirChat('comando', impresso.slice(-20000));
-            }
-        }
-        ocupado = false;
-        emitir('ocupado', false);
-        emitir('estado', estadoAgora());
-    }
-
-    const servidor = http.createServer((req, res) => {
-        atender(req, res).catch((e) => {
-            // Uma exceção solta aqui vira unhandledRejection e derruba o CLI
-            // INTEIRO junto com a janela — o trabalho da pessoa some porque
-            // uma listagem tropeçou. Aqui ela vira um 500 e a janela segue.
-            try {
-                if (!res.headersSent) res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: false, error: e.message }));
-            } catch { /* socket já foi */ }
-        });
-    });
-
-    function json(res, status, corpo) {
-        res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store' });
-        res.end(JSON.stringify(corpo));
-    }
-
-    async function atender(req, res) {
-        const url = new URL(req.url, 'http://127.0.0.1');
-        const rota = url.pathname;
-        const POST = req.method === 'POST';
-
-        /* A chave protege a API, que é onde está tudo o que importa: a conversa
-           do usuário e a capacidade de dar ordens ao agente. A página em si —
-           HTML, CSS, JS — não guarda segredo nenhum e não faz nada sem a
-           chave, então ela é servida solta (exigir chave nos estáticos
-           quebrava a janela: o navegador pede /app.css sem parâmetro). */
-        if (rota.startsWith('/api/')) {
-            // A prévia leva a chave no CAMINHO (ver lib/painel.js): os
-            // arquivos que a página do projeto pede por endereço relativo não
-            // carregam query nenhuma.
-            const naPrevia = rota.match(/^\/api\/previa\/([0-9a-f]+)/);
-            const dada = (naPrevia && naPrevia[1]) || url.searchParams.get('k') || req.headers['x-primo-chave'];
-            if (dada !== chave) {
-                res.writeHead(403, { 'Content-Type': 'text/plain; charset=utf-8' });
-                return res.end('chave inválida — abra a janela com o comando /rc');
-            }
-        }
-        /* CSRF: uma página de terceiro consegue disparar POST simples para
-           127.0.0.1 sem preflight. Ela não saberia a chave, mas o cinto e o
-           suspensório custam três linhas. A exceção é a prévia: ela roda num
-           iframe sandbox de origem opaca (`Origin: null`), só GET e só nas
-           rotas que LEEM o projeto. */
-        const origem = req.headers.origin;
-        const previaOpaca = origem === 'null' && req.method === 'GET' && rota.startsWith('/api/previa/');
-        if (origem && !previaOpaca && !origem.startsWith(`http://127.0.0.1:${servidor.__porta}`)
-            && !origem.startsWith(`http://localhost:${servidor.__porta}`)) {
-            res.writeHead(403).end();
-            return;
-        }
-
-        if (rota === '/api/fluxo') {
-            res.writeHead(200, {
-                'Content-Type': 'text/event-stream; charset=utf-8',
-                'Cache-Control': 'no-cache',
-                Connection: 'keep-alive',
-                // Sem isto um proxy no meio segura os eventos até fechar.
-                'X-Accel-Buffering': 'no',
-            });
-            res.write(': ligado\n\n');
-            ouvintes.add(res);
-            res.write(`event: estado\ndata: ${JSON.stringify(estadoAgora())}\n\n`);
-            res.write(`event: terminal\ndata: ${JSON.stringify(memoria.join(''))}\n\n`);
-            res.write(`event: historia\ndata: ${JSON.stringify(conversa)}\n\n`);
-            res.write(`event: ocupado\ndata: ${JSON.stringify(ocupado)}\n\n`);
-            // Batida a cada 20s: proxy e sistema derrubam conexão parada.
-            const batida = setInterval(() => { try { res.write(': ok\n\n'); } catch {} }, 20000);
-            req.on('close', () => { clearInterval(batida); ouvintes.delete(res); });
-            return;
-        }
-
-        if (rota === '/api/enviar' && POST) {
-            const d = await lerJson(req, 200000);
-            const texto = d && typeof d.texto === 'string' ? d.texto : '';
-            json(res, 200, { ok: true });
-            if (texto.trim()) processar(texto);
-            return;
-        }
-
-        if (rota === '/api/parar' && POST) {
-            try { op.interromper(); } catch {}
-            return json(res, 200, { ok: true });
-        }
-
-        if (rota === '/api/estado') return json(res, 200, estadoAgora());
-
-        // ── projetos ────────────────────────────────────────────────────
-        const listar = () => (op.projetos ? op.projetos() : extra.listarProjetos(cfg.ROOT_DIR));
-        if (rota === '/api/projetos') {
-            const atual = (op.estado() || {}).projeto;
-            const projetos = listar().map((p) => ({
-                nome: p.nome, modificado: p.modificado || null, arquivos: p.arquivos || 0, atual: p.nome === atual,
-            }));
-            return json(res, 200, { ok: true, projetos });
-        }
-        if (rota === '/api/projeto' && POST) {
-            if (ocupado) return json(res, 409, { ok: false, error: 'o Primo está trabalhando — pare ou espere para trocar de projeto' });
-            const d = await lerJson(req);
-            if (!d) return json(res, 400, { ok: false, error: 'pedido ilegível' });
-            let dir = null;
-            /* Só entra em projeto que ESTÁ na lista de ~/primocode, por nome
-               exato. Aceitar um caminho aqui daria à página o poder de apontar
-               o agente para qualquer pasta do disco. */
-            if (typeof d.nome === 'string') {
-                const achado = listar().find((p) => p.nome === d.nome);
-                if (!achado) return json(res, 404, { ok: false, error: 'não achei esse projeto em ~/primocode' });
-                dir = achado.dir;
-            } else if (typeof d.novo === 'string') {
-                const nome = d.novo.trim().slice(0, 60);
-                if (!cfg.slugify(nome)) return json(res, 400, { ok: false, error: 'dê um nome com letras ou números' });
-                dir = cfg.createProjectDir(nome);
-            } else return json(res, 400, { ok: false, error: 'faltou o nome do projeto' });
-            if (op.entrarProjeto) await op.entrarProjeto(dir);
-            else await op.barra('/dir ' + dir);
-            emitir('estado', estadoAgora());
-            return json(res, 200, { ok: true, estado: estadoAgora() });
-        }
-
-        // ── conversa ────────────────────────────────────────────────────
-        if (rota === '/api/novo-chat' && POST) {
-            if (ocupado) return json(res, 409, { ok: false, error: 'o Primo está trabalhando — pare antes de começar outro chat' });
-            if (op.novoChat) await op.novoChat();
-            else await op.barra('/clear');
-            conversa = [];
-            emitir('limpar', true);
-            emitir('estado', estadoAgora());
-            return json(res, 200, { ok: true });
-        }
-
-        /* "Recentes": as conversas da conta quando há conta (as mesmas do
-           /chats, do app e do celular); sem conta, os últimos pedidos
-           deste computador. A janela não fala com o Firestore por conta
-           própria — uma segunda implementação da cifra divergiria. */
-        if (rota === '/api/recentes') {
-            const nuvem = require('./nuvem.js');
-            const r = await nuvem.listarConversas({ limite: 30 }).catch(() => ({ ok: false }));
-            if (r && r.ok) {
-                return json(res, 200, { ok: true, fonte: 'nuvem', itens: r.conversas.map((c) => ({
-                    id: c.id, titulo: c.titulo, quando: c.atualizada, mensagens: c.mensagens })) });
-            }
-            return json(res, 200, { ok: true, fonte: 'local', itens: recentesLocais(cfg.HISTORY_FILE) });
-        }
-
-        if (rota === '/api/conversa/abrir' && POST) {
-            if (ocupado) return json(res, 409, { ok: false, error: 'o Primo está trabalhando' });
-            const d = await lerJson(req);
-            if (!d || typeof d.id !== 'string' || !d.id) return json(res, 400, { ok: false, error: 'faltou a conversa' });
-            const r = op.continuarConversa
-                ? await op.continuarConversa({ id: d.id, titulo: String(d.titulo || '') })
-                : await require('./nuvem.js').lerConversa(d.id);
-            if (!r || !r.ok) return json(res, 200, { ok: false, error: (r && r.error) || 'não abriu' });
-            // A conversa aberta vira a da tela: pedido como balão, resposta
-            // como fala — e um F5 depois continua mostrando ela.
-            conversa = (r.mensagens || []).map((m) => (m.papel === 'user'
-                ? { evento: 'voce', dados: String(m.texto || '') }
-                : { evento: 'agente', dados: { tipo: 'resposta', texto: String(m.texto || '') } }));
-            emitir('historia', conversa);
-            return json(res, 200, { ok: true, mensagens: (r.mensagens || []).length });
-        }
-
-        // ── o compositor ────────────────────────────────────────────────
-        if (rota === '/api/permissoes' && POST) {
-            const d = await lerJson(req);
-            const m = d && d.modo;
-            if (!perigo.MODOS.includes(m)) return json(res, 400, { ok: false, error: 'use auto, perguntar ou livre' });
-            if (op.mudarPermissoes) await op.mudarPermissoes(m);
-            else await op.barra('/permissoes ' + m);
-            emitir('estado', estadoAgora());
-            return json(res, 200, { ok: true, estado: estadoAgora() });
-        }
-
-        if (rota === '/api/esforco' && POST) {
-            const d = await lerJson(req);
-            const n = d && d.nivel;
-            if (!effort.NOMES.includes(n)) return json(res, 400, { ok: false, error: 'esforço desconhecido' });
-            if (op.mudarEsforco) await op.mudarEsforco(n);
-            else await op.barra('/effort ' + n);
-            emitir('estado', estadoAgora());
-            return json(res, 200, { ok: true, estado: estadoAgora() });
-        }
-
-        if (rota === '/api/anexar' && POST) {
-            const d = await lerJson(req, Math.ceil(MAX_ANEXO * 1.4) + 4096);
-            if (d && d.__grande) return json(res, 413, { ok: false, error: 'maior que 2 MB' });
-            if (!d || typeof d.nome !== 'string' || typeof d.base64 !== 'string') {
-                return json(res, 400, { ok: false, error: 'faltou o arquivo' });
-            }
-            // Só o NOME: o que vem da página não escolhe caminho nenhum.
-            const nome = path.basename(d.nome.replace(/\\/g, '/')).replace(/[\x00-\x1f]/g, '').slice(0, 120);
-            const buf = Buffer.from(d.base64, 'base64');
-            if (!nome) return json(res, 400, { ok: false, error: 'nome inválido' });
-            if (buf.length > MAX_ANEXO) return json(res, 413, { ok: false, error: 'maior que 2 MB' });
-            if (require('./painel.js').ehBinario(buf)) {
-                return json(res, 415, { ok: false, error: `${nome} não é texto — anexe código, texto ou dados (imagem e vídeo, peça pelo caminho)` });
-            }
-            if (!op.anexar) return json(res, 501, { ok: false, error: 'anexo indisponível aqui' });
-            await op.anexar({ path: nome, content: buf.toString('utf8') });
-            emitir('estado', estadoAgora());
-            return json(res, 200, { ok: true, estado: estadoAgora() });
-        }
-
-        if (rota === '/api/desanexar' && POST) {
-            const d = await lerJson(req);
-            if (op.desanexar) await op.desanexar(d && typeof d.nome === 'string' ? d.nome : undefined);
-            else await op.barra('/detach');
-            emitir('estado', estadoAgora());
-            return json(res, 200, { ok: true, estado: estadoAgora() });
-        }
-
-        if (rota === '/api/voz' && POST) {
-            const d = await lerJson(req);
-            const ligar = !!(d && d.ligar);
-            if (op.voz) await op.voz(ligar);
-            else await op.barra(ligar ? '/voice' : '/voice parar');
-            emitir('estado', estadoAgora());
-            return json(res, 200, { ok: true, estado: estadoAgora() });
-        }
-
-        if (rota.startsWith('/api/conversa/') && req.method === 'GET') {
-            const id = decodeURIComponent(rota.slice('/api/conversa/'.length));
-            const r = await require('./nuvem.js').lerConversa(id).catch((e) => ({ ok: false, error: e.message }));
-            return json(res, 200, r);
-        }
-
-        if (painel && await painel.atender(req, res, url)) return;
-        if (rota.startsWith('/api/')) return json(res, 404, { ok: false, error: 'rota desconhecida' });
-
-        // Estáticos. `basename` corta qualquer "../" antes de virar caminho:
-        // este servidor fala com o disco do usuário e não pode servir o que
-        // estiver fora da pasta do aplicativo. /ide é a mesma janela: a IDE
-        // antiga virou o painel da direita.
-        const nome = (rota === '/' || rota === '/ide') ? 'index.html' : path.basename(rota);
-        const arquivo = path.join(WEB, nome);
-        fs.readFile(arquivo, (erro, dados) => {
-            if (erro) { res.writeHead(404).end('não encontrado'); return; }
-            res.writeHead(200, { 'Content-Type': tipoDe(nome), 'Cache-Control': 'no-store' });
-            res.end(dados);
-        });
-    }
-
-    const porta = await escutar(servidor, PORTA_PADRAO);
-    servidor.__porta = porta;
-    const url = `http://127.0.0.1:${porta}/?k=${chave}`;
-    // A mesma janela, abrindo com a prévia à direita — o que o /ide virou.
-    const urlPainel = `${url}&painel=previa`;
-
-    // `semJanela` é para o teste (e para quem só quer o endereço): sem ele,
-    // rodar a suíte abriria uma janela de verdade na tela de quem roda.
-    const janela = op.semJanela ? { modo: 'nenhum' }
-        : await abrirJanela(op.abrirEm === 'ide' ? urlPainel : url);
-    return {
-        url, urlPainel, porta, chave, servidor, janela,
-        /** Um pedido digitado no TERMINAL, para aparecer como balão na janela. */
-        pedidoDoTerminal(texto) { if (String(texto || '').trim()) emitirChat('voce', String(texto).trim()); },
-        fechar() {
-            try { pararEspelho(); } catch {}
-            try { fala.eventos.removeListener('evento', aoFalar); } catch {}
-            try { if (painel) painel.fechar(); } catch {}
-            try { servidor.close(); } catch {}
-            // SSE abertos seguram o close() para sempre; a janela é que
-            // fechou, então as conexões dela também.
-            for (const r of ouvintes) { try { r.end(); } catch {} }
-        },
-    };
-}
-
-/* Porta ocupada não é erro: é outra janela do PrimoCode, ou qualquer coisa
-   que pegou a 7788 primeiro. Anda dez casas e desiste — se dez portas
-   seguidas estão tomadas, o problema é outro. */
-function escutar(servidor, inicial) {
-    return new Promise((ok, falha) => {
-        let porta = inicial;
-        const tentar = () => {
-            servidor.once('error', (e) => {
-                if (e.code === 'EADDRINUSE' && porta < inicial + 10) { porta++; tentar(); }
-                else falha(e);
-            });
-            servidor.listen(porta, '127.0.0.1', () => ok(porta));
-        };
-        tentar();
-    });
-}
-
-/* ── a janela ────────────────────────────────────────────────────────────
-   `--app=` abre sem barra de endereço, sem abas e com entrada própria na
-   barra de tarefas: é o que faz parecer aplicativo em vez de site. Chrome,
-   Edge, Brave e Vivaldi entendem, porque todos são Chromium.
-
-   `--user-data-dir` aponta para uma pasta do PrimoCode de propósito: sem ele,
-   o Chrome que JÁ ESTÁ ABERTO recebe o pedido e devolve uma aba comum — o
-   modo app é ignorado quando há um perfil em uso. Com perfil próprio nasce
-   uma janela de verdade, e o histórico do usuário fica fora disto. */
-function candidatosDeNavegador() {
-    const p = os.platform();
-    if (p === 'darwin') {
-        return [
-            '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
-            '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
-            '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
-            '/Applications/Chromium.app/Contents/MacOS/Chromium',
-            '/Applications/Arc.app/Contents/MacOS/Arc',
-        ];
-    }
-    if (p === 'win32') {
-        const bases = [process.env['PROGRAMFILES'], process.env['PROGRAMFILES(X86)'],
-            process.env.LOCALAPPDATA].filter(Boolean);
-        const relativos = [
-            'Google\\Chrome\\Application\\chrome.exe',
-            'Microsoft\\Edge\\Application\\msedge.exe',
-            'BraveSoftware\\Brave-Browser\\Application\\brave.exe',
-        ];
-        const fora = [];
-        for (const b of bases) for (const r of relativos) fora.push(path.join(b, r));
-        return fora;
-    }
-    return ['/usr/bin/google-chrome', '/usr/bin/google-chrome-stable', '/usr/bin/chromium',
-        '/usr/bin/chromium-browser', '/usr/bin/microsoft-edge', '/usr/bin/brave-browser'];
-}
-
-function abrirJanela(url) {
-    const perfil = path.join(os.homedir(), '.primocode', 'janela');
-    try { fs.mkdirSync(perfil, { recursive: true }); } catch {}
-
-    for (const exe of candidatosDeNavegador()) {
-        if (!fs.existsSync(exe)) continue;
-        try {
-            const filho = execFile(exe, [
-                `--app=${url}`,
-                `--user-data-dir=${perfil}`,
-                // Sem Keychain: ver SEM_KEYCHAIN em lib/browser.js.
-                ...require('./browser.js').SEM_KEYCHAIN,
-                '--window-size=1180,820',
-                '--no-first-run',
-                '--no-default-browser-check',
-            ], () => {});
-            // A janela é do usuário: se o PrimoCode do terminal terminar, ela
-            // continua de pé.
-            filho.unref();
-            return Promise.resolve({ modo: 'janela', navegador: path.basename(exe) });
-        } catch { /* tenta o próximo */ }
-    }
-
-    // Nenhum Chromium instalado: aba comum no navegador padrão. Funciona
-    // igual — só não fica com cara de aplicativo.
-    const p = os.platform();
-    const [cmd, args] = p === 'darwin' ? ['open', [url]]
-        : p === 'win32' ? ['cmd.exe', ['/c', 'start', '', url]]
-        : ['xdg-open', [url]];
-    return new Promise((ok) => {
-        execFile(cmd, args, { timeout: 10000 }, (erro) => {
-            ok(erro ? { modo: 'nenhum', erro: erro.message } : { modo: 'aba' });
-        });
-    });
-}
-
-module.exports = { abrir, abrirJanela, espelhar, ehRuido, candidatosDeNavegador, recentesLocais, MAX_ANEXO };