primocode 9.8.0-beta.2 → 9.8.0-beta.21

package/lib/app.js

@@ -23,14 +23,18 @@
  * navegador em modo app. Se não houver nenhum navegador de Chromium, abre
  * numa aba normal, que continua funcionando.
  *
- * ── POR QUE ELE ESPELHA O TERMINAL ───────────────────────────────────────
- * O pedido foi "um chat estilo terminal para quem não quer o terminal" — e o
- * agente já conta o que faz, linha por linha, com cor. Reescrever essa saída
- * para a web daria duas verdades para manter, e uma delas ficaria velha.
+ * ── 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").
  *
- * Aqui a saída é a MESMA: o `process.stdout.write` é espelhado, os códigos
- * ANSI viram cor de verdade na página, e o terminal continua imprimindo
- * normalmente. Quem abrir os dois vê a mesma coisa nos dois.
+ * 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
@@ -47,6 +51,11 @@ 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;
@@ -89,15 +98,87 @@ function tipoDe(arquivo) {
     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, modo, esforco, projeto }
+ * @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');
@@ -105,10 +186,15 @@ async function abrir(op) {
     let ocupado = false;
     const fila = [];
 
-    // O histórico de saída para quem abrir a janela DEPOIS de o agente já ter
-    // começado — sem isto a página nasceria vazia no meio de uma tarefa.
+    // 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`;
@@ -116,8 +202,27 @@ async function abrir(op) {
             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();
@@ -132,28 +237,31 @@ async function abrir(op) {
         while (fila.length) {
             const t = String(fila.shift() || '').trim();
             if (!t) continue;
-            emitir('voce', t);
+            emitirChat('voce', t);
+            falouNesta = false;
+            capturando = [];
             try {
                 if (t.startsWith('/')) await op.barra(t);
                 else await op.enviar(t);
             } catch (e) {
-                emitir('erro', (e && e.message) || String(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', op.estado());
+        emitir('estado', estadoAgora());
     }
 
-    // `async` por causa das rotas de histórico, que esperam a nuvem. Uma
-    // exceção aqui viraria unhandledRejection e derrubaria o CLI inteiro
-    // junto com a janela, então o corpo fica dentro de um try/catch.
     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 de conversa tropeçou. Aqui ela vira um 500 e a
-            // janela segue de pé.
+            // 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 }));
@@ -161,31 +269,40 @@ async function abrir(op) {
         });
     });
 
+    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.
-
-           Não é frouxidão, é o contrário: exigir chave nos estáticos também
-           quebrava a própria janela, porque o navegador pede /app.css e
-           /app.js sem parâmetro nenhum. A página vinha, ficava sem estilo e
-           sem script, e o "app bonito" era um formulário branco. */
+           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/')) {
-            const dada = url.searchParams.get('k') || req.headers['x-primo-chave'];
+            // 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 /app');
+                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. */
+           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;
-        if (origem && !origem.startsWith(`http://127.0.0.1:${servidor.__porta}`)
+        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;
@@ -201,72 +318,181 @@ async function abrir(op) {
             });
             res.write(': ligado\n\n');
             ouvintes.add(res);
-            res.write(`event: estado\ndata: ${JSON.stringify(op.estado())}\n\n`);
-            for (const pedaco of memoria) {
-                res.write(`event: saida\ndata: ${JSON.stringify(pedaco)}\n\n`);
-            }
+            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, e
-            // uma janela que "morre sozinha depois de um tempo" seria um bug
-            // impossível de achar depois.
+            // 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' && req.method === 'POST') {
-            let corpo = '';
-            req.on('data', (c) => { corpo += c; if (corpo.length > 200000) req.destroy(); });
-            req.on('end', () => {
-                let texto = '';
-                try { texto = JSON.parse(corpo).texto || ''; } catch { /* vazio */ }
-                res.writeHead(200, { 'Content-Type': 'application/json' }).end('{"ok":true}');
-                if (texto.trim()) processar(texto);
-            });
+        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' && req.method === 'POST') {
+        if (rota === '/api/parar' && POST) {
             try { op.interromper(); } catch {}
-            res.writeHead(200, { 'Content-Type': 'application/json' }).end('{"ok":true}');
-            return;
+            return json(res, 200, { ok: true });
         }
 
-        /* O HISTÓRICO da janela vem do MESMO lugar que o do terminal:
-           lib/nuvem.js, coleção `primocode`, cifrado. A janela não fala com o
-           Firestore por conta própria — ela pergunta ao servidor dela, que já
-           tem a sessão e a cifra. Um segundo caminho até o banco significaria
-           uma segunda implementação da cifra, e a segunda divergiria da
-           primeira sem ninguém ver. */
-        if (rota === '/api/conversas') {
-            const nuvem = require('./nuvem.js');
-            const r = await nuvem.listarConversas({ limite: 40 })
-                .catch((e) => ({ ok: false, error: e.message }));
-            res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
-            return res.end(JSON.stringify(r));
+        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 });
         }
 
-        if (rota.startsWith('/api/conversa/')) {
+        /* "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 id = decodeURIComponent(rota.slice('/api/conversa/'.length));
-            const r = await nuvem.lerConversa(id).catch((e) => ({ ok: false, error: e.message }));
-            res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
-            return res.end(JSON.stringify(r));
+            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/estado') {
-            res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
-            return res.end(JSON.stringify(Object.assign({ versao: op.versao }, op.estado())));
+        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.
-        const nome = rota === '/' ? 'index.html' : path.basename(rota);
+        // 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) });
+            res.writeHead(200, { 'Content-Type': tipoDe(nome), 'Cache-Control': 'no-store' });
             res.end(dados);
         });
     }
@@ -274,11 +500,26 @@ async function abrir(op) {
     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`;
 
-    const janela = await abrirJanela(url);
+    // `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, porta, chave, servidor, janela,
-        fechar() { try { pararEspelho(); } catch {} try { servidor.close(); } catch {} },
+        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 {} }
+        },
     };
 }
 
@@ -345,6 +586,8 @@ function abrirJanela(url) {
             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',
@@ -369,4 +612,4 @@ function abrirJanela(url) {
     });
 }
 
-module.exports = { abrir, abrirJanela, espelhar, ehRuido, candidatosDeNavegador };
+module.exports = { abrir, abrirJanela, espelhar, ehRuido, candidatosDeNavegador, recentesLocais, MAX_ANEXO };