primocode 9.3.0 → 9.4.0

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v9.2.4
+# PrimoCode v9.4.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 v9.2.4
+ ▐▛███▜▌   Primo Code v9.4.0
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/app/index.html

@@ -40,7 +40,7 @@
     <div class="rotulo">Conversas</div>
     <div class="recentes" id="recentes">
       <div class="vazio-lista" id="listaVazia">
-        As conversas aparecem aqui quando você entra na sua conta com <code>/connect</code>.
+        As conversas aparecem aqui quando você entra na sua conta com <code>/login</code>.
       </div>
     </div>
 

package/bin/primocode.js

@@ -35,6 +35,7 @@ const vozModo = require('../lib/voz');
 const appLib = require('../lib/app');
 const conta = require('../lib/conta');
 const nuvem = require('../lib/nuvem');
+const compat = require('../lib/compatibilidade');
 
 // Rede de segurança de último recurso: sem isto, uma exceção fora de um
 // try/catch (ex.: dentro de um callback de socket, como o parser de SSE) não
@@ -103,7 +104,7 @@ ${c.bold('Comandos')}
   ${c.brand('/run')} <comando>      executa no shell do projeto
   ${c.brand('/open')} <arq|url>     abre no navegador
   ${c.brand('/rc')}                 abre a janela do PrimoCode (chat, sem terminal)
-  ${c.brand('/connect')}            entra na sua conta · ${c.brand('/account')} mostra o plano
+  ${c.brand('/login')}              entra na sua conta · ${c.brand('/account')} mostra o plano
   ${c.brand('/chats')} [n]          suas conversas — as mesmas do app e do celular
   ${c.brand('/logout')}             desconecta este computador da conta
   ${c.brand('/status')}             checa o servidor
@@ -147,7 +148,7 @@ const SLASH_COMANDOS = [
     ['/run', 'roda um comando'],
     ['/open', 'abre no navegador'],
     ['/rc', 'abre a janela do PrimoCode'],
-    ['/connect', 'entra na sua conta Conecta Primo'],
+    ['/login', 'entra na sua conta Conecta Primo'],
     ['/account', 'sua conta, plano e computadores conectados'],
     ['/chats', 'suas conversas salvas, as mesmas do app e do celular'],
     ['/logout', 'desconecta este computador da conta'],
@@ -381,6 +382,42 @@ function ask(question) {
     });
 }
 
+/**
+ * Pergunta sem mostrar o que se digita — para a senha do /login.
+ *
+ * Com a caixa de digitar no ar, ela mesma oculta a próxima linha (ver
+ * `ocultarProxima` em lib/entrada.js). Sem a caixa, o readline ecoa cada
+ * tecla pelo `_writeToOutput`; enquanto a pergunta está aberta, só a quebra
+ * de linha passa. Nos dois casos a resposta fica fora do histórico: senão a
+ * seta para cima devolveria a senha na tela.
+ */
+function askSecret(question) {
+    if (!process.stdin.isTTY) return ask(question);
+    if (rl && typeof rl.ocultarProxima === 'function') {
+        return new Promise((resolve) => {
+            process.stdout.write(question);
+            rl.ocultarProxima();
+            pendingAsk = resolve;
+        });
+    }
+    return new Promise((resolve) => {
+        const alvo = rl || readline.createInterface({ input: process.stdin, output: process.stdout });
+        const original = alvo._writeToOutput;
+        process.stdout.write(question);
+        alvo._writeToOutput = function (texto) {
+            if (/[\r\n]/.test(texto)) original.call(alvo, '\n');
+        };
+        const fim = (resposta) => {
+            alvo._writeToOutput = original;
+            if (Array.isArray(alvo.history) && alvo.history[0] === resposta) alvo.history.shift();
+            if (!rl) alvo.close();
+            resolve(resposta);
+        };
+        if (rl) pendingAsk = fim;
+        else alvo.question('', fim);
+    });
+}
+
 async function confirm(question) {
     const raw = await ask(`${c.brand('?')} ${question} ${c.muted('(S/n)')} `);
     if (!process.stdin.isTTY) process.stdout.write('\n'); // pipe não ecoa o Enter
@@ -730,7 +767,7 @@ async function sendPrompt(userText) {
     if (state.liberado === false) {
         console.log(c.err('  O PrimoCode pede o plano Premium ou Super.'));
         console.log(c.muted('  Assine em ') + c.brand('conecta-primo-ai.vercel.app')
-            + c.muted(' · já assinou? ') + c.brand('/connect'));
+            + c.muted(' · já assinou? ') + c.brand('/login'));
         return;
     }
 
@@ -1104,7 +1141,7 @@ const RENOMEADOS = {
     // o que abre a janela
     app: 'rc',
     // a conta
-    entrar: 'connect', login: 'connect', conectar: 'connect',
+    entrar: 'login', conectar: 'login',
     conta: 'account',
     sair: 'exit',        // sair é SAIR; desconectar a conta é /logout
     // o histórico
@@ -1735,52 +1772,25 @@ async function handleSlash(text) {
             break;
         }
 
-        /* A conta do Conecta Primo. O login inteiro mora em lib/conta.js;
-           aqui é a tela dele. */
-        case 'connect': {
+        /* A conta do Conecta Primo, sem navegador: e-mail e senha aqui
+           mesmo. O login inteiro mora em lib/conta.js; aqui é a tela dele. */
+        case 'login': {
             const jaEsta = conta.atual();
             if (jaEsta && rest !== 'trocar') {
-                console.log(c.muted('  Já conectado como ') + c.brand(jaEsta.uid.slice(0, 12) + '…')
+                console.log(c.muted('  Já conectado como ') + c.brand(jaEsta.email || (jaEsta.uid.slice(0, 12) + '…'))
                     + c.muted(` · plano ${jaEsta.plano}`));
-                console.log(c.dim('  Para entrar com outra conta: ') + c.brand('/connect trocar'));
+                console.log(c.dim('  Para entrar com outra conta: ') + c.brand('/login trocar'));
                 break;
             }
             if (rest === 'trocar') conta.sair();
 
-            const sp = new Spinner('abrindo o login').start();
-            const r = await conta.entrar({
-                abrir: (u) => tools.openInBrowser(u),
-                contar: (info) => {
-                    sp.stop();
-                    const meio = info.codigo.length === 8
-                        ? info.codigo.slice(0, 4) + '-' + info.codigo.slice(4) : info.codigo;
-                    console.log(c.muted('  Abrindo no navegador:'));
-                    console.log('  ' + c.brand(info.url.replace(/[?&]porta=\d+/, '')));
-                    console.log('');
-                    if (info.porta) {
-                        /* COM O SERVIDOR LOCAL DE PÉ, NÃO HÁ CÓDIGO PARA LER. A
-                           página pergunta ao 127.0.0.1 desta máquina, recebe o
-                           código e aprova sozinha assim que a pessoa entra com a
-                           conta — "não precisa colocar código, não precisa pra
-                           nada, porque ele já libera". Mostrar as oito letras
-                           grandes aqui era pedir para ler o que ninguém precisa
-                           mais; elas ficam numa linha apagada, só para o caso
-                           de o navegador bloquear o 127.0.0.1 (Safari) e a
-                           página voltar a pedir. */
-                        console.log('  ' + c.white('Entre com a sua conta na página que abriu — o resto é automático.'));
-                        console.log(c.dim(`  Se a página pedir um código: ${meio}${info.copiado ? ' (já copiado)' : ''}.`));
-                    } else {
-                        /* Sem porta local (ocupadas, ou bloqueadas), o código
-                           volta a ser o caminho — grande, partido em dois,
-                           porque é o que se lê de uma tela e se confere noutra. */
-                        console.log('    ' + c.bold(c.brand(meio.split('').join(' '))));
-                        console.log('');
-                        console.log(c.dim('  ' + (info.copiado ? 'O código já está copiado — cole na página.'
-                            : 'Digite o código na página.')));
-                    }
-                    console.log(c.dim('  Esperando o navegador…'));
-                },
-            });
+            const email = String(await ask(c.brand('  E-mail: ')) || '').trim();
+            if (!email) { console.log(c.muted('  Login cancelado.')); break; }
+            const senha = await askSecret(c.brand('  Senha: '));
+            if (!senha) { console.log(c.muted('  Login cancelado.')); break; }
+
+            const sp = new Spinner('entrando').start();
+            const r = await conta.entrar({ email, senha });
             sp.stop();
             if (!r.ok) { console.log(c.err(`  ${r.error}`)); break; }
             console.log(c.ok('  Conectado.')
@@ -1792,7 +1802,7 @@ async function handleSlash(text) {
            mostram. Sem número, lista; com número, abre e continua dali. */
         case 'chats': {
             if (!conta.atual()) {
-                console.log(c.muted('  Não conectado. ') + c.brand('/connect')
+                console.log(c.muted('  Não conectado. ') + c.brand('/login')
                     + c.muted(' para ver suas conversas aqui, no app e no celular.'));
                 break;
             }
@@ -1841,14 +1851,14 @@ async function handleSlash(text) {
             if (!conta.atual()) { console.log(c.muted('  Você não está conectado.')); break; }
             conta.sair();
             console.log(c.ok('  Desconectado deste computador.')
-                + c.dim('  A conta continua intacta; entre de novo com /connect.'));
+                + c.dim('  A conta continua intacta; entre de novo com /login.'));
             break;
         }
 
         case 'account': {
             const eu = conta.atual();
             if (!eu) {
-                console.log(c.muted('  Não conectado. ') + c.brand('/connect') + c.muted(' para entrar.'));
+                console.log(c.muted('  Não conectado. ') + c.brand('/login') + c.muted(' para entrar.'));
                 break;
             }
             const sp = new Spinner('conferindo').start();
@@ -1942,6 +1952,33 @@ function shortPath(p) {
     return full.startsWith(home + '/') ? '~' + full.slice(home.length) : full;
 }
 
+/* O CLIENTE NOVO E O SERVIDOR VELHO.
+ *
+ * Quem declara ao modelo quais ferramentas existem é o servidor. Quando a
+ * lista dele fica para trás, o que a pessoa vê é "a ferramenta não está
+ * disponível" e tarefas que param no meio — duas frases que não apontam para
+ * a causa. Uma linha no começo da sessão troca isso por algo acionável.
+ *
+ * Sem prender nada: a busca corre em paralelo e, se o servidor estiver
+ * dormindo ou a rede fora, não se diz nada. Acusar o servidor porque a rede
+ * caiu manda consertar o que não quebrou. */
+let jaConferiu = false;
+function conferirServidor() {
+    if (jaConferiu) return;
+    jaConferiu = true;
+    const minimo = (pkg.primocode && pkg.primocode.servidorMinimo) || '';
+    if (!minimo) return;
+    const servidor = state.config.server;
+    Promise.resolve()
+        .then(() => api.getHealth(servidor, state.config.token))
+        .then((saude) => {
+            const r = compat.avaliar({ saude, minimo, servidor });
+            const texto = compat.aviso(r, c);
+            if (texto) console.log('\n' + texto + '\n');
+        })
+        .catch(() => {});
+}
+
 async function main() {
     cfg.ensureStructure();
 
@@ -2185,7 +2222,7 @@ async function main() {
         cores: c,
         interativo: !!(process.stdin.isTTY && process.stdout.isTTY),
         conectado: () => conta.atual(),
-        conectar: () => handleSlash('/connect').then(() => conta.atual()),
+        conectar: () => handleSlash('/login').then(() => conta.atual()),
         sessao: () => conta.sessao(),
     }).then((r) => {
         // O bloqueio de quem não é Premium/Super. É de CORTESIA: este arquivo
@@ -2200,6 +2237,7 @@ async function main() {
         while (adiantadas.length) queue.push(adiantadas.shift());
         if (queue.length) drain();
         else if (!closed) rl.prompt();
+        conferirServidor();
     });
 }
 

package/lib/boas-vindas.js

@@ -17,6 +17,9 @@
  * A API vem configurada no produto. Entrou na conta, pode pedir a primeira
  * coisa.
  *
+ * Desde 23/09/2026 o login não abre mais o navegador: é e-mail e senha no
+ * próprio terminal (/login, ver lib/conta.js).
+ *
  * ── O BLOQUEIO É DE CORTESIA ─────────────────────────────────────────────
  * Este arquivo vai publicado no npm com o código à vista: um `if (pro)` aqui
  * é uma linha que qualquer um apaga. Quem segura de verdade é o
@@ -59,7 +62,7 @@ function esquecer() {
  * @param {object} op.cores
  * @param {boolean} op.interativo      false = pipe/CI: não pergunta nada
  * @param {()=>any} op.conectado       a credencial local, ou null
- * @param {()=>Promise<any>} op.conectar   roda o login (abre o navegador)
+ * @param {()=>Promise<any>} op.conectar   roda o login (e-mail e senha no terminal)
  * @param {()=>Promise<any>} op.sessao     confirma o plano NO SERVIDOR
  */
 async function rodar({ perguntar, mostrar, cores: c, interativo = true,
@@ -78,13 +81,12 @@ async function rodar({ perguntar, mostrar, cores: c, interativo = true,
         mostrar('');
         mostrar(c.bold(c.brand('  Bem-vindo ao PrimoCode.')));
         mostrar(c.muted('  Primeiro, entre na sua conta do Conecta Primo AI.'));
-        mostrar(c.dim('  Vou abrir o navegador; é só entrar com a conta por lá — o resto é automático.'));
         mostrar('');
         const r = await conectar();
         if (!r || r.ok === false) {
             mostrar('');
             mostrar(c.err('  Não deu para conectar' + (r && r.error ? `: ${r.error}` : '.')));
-            mostrar(c.muted('  Tente de novo com ') + c.brand('/connect') + c.muted('.'));
+            mostrar(c.muted('  Tente de novo com ') + c.brand('/login') + c.muted('.'));
             return { liberado: false, motivo: 'sem-login' };
         }
         credencial = conectado ? conectado() : { plano: r.plano };
@@ -102,7 +104,7 @@ async function rodar({ perguntar, mostrar, cores: c, interativo = true,
     } else if (!s || !s.ok) {
         mostrar('');
         mostrar(c.err('  Não consegui confirmar sua conta' + (s && s.error ? `: ${s.error}` : '.')));
-        mostrar(c.muted('  Entre de novo com ') + c.brand('/connect') + c.muted('.'));
+        mostrar(c.muted('  Entre de novo com ') + c.brand('/login') + c.muted('.'));
         return { liberado: false, motivo: 'sessao-invalida' };
     }
 
@@ -116,7 +118,7 @@ async function rodar({ perguntar, mostrar, cores: c, interativo = true,
         mostrar('');
         mostrar(c.dim('  Assine em ') + c.brand('conecta-primo-ai.vercel.app')
             + c.dim(' e rode ') + c.brand('primo') + c.dim(' de novo.'));
-        mostrar(c.dim('  Já assinou? ') + c.brand('/connect')
+        mostrar(c.dim('  Já assinou? ') + c.brand('/login')
             + c.dim(' atualiza o plano nesta máquina.'));
         mostrar('');
         return { liberado: false, motivo: 'sem-plano', plano };

package/lib/compatibilidade.js

@@ -0,0 +1,89 @@
+/**
+ * compatibilidade.js — o cliente novo conversando com o servidor velho.
+ *
+ * ── O SINTOMA, E POR QUE ELE ENGANA ──────────────────────────────────────
+ * Quem declara ao modelo QUAIS ferramentas existem é o servidor. Uma que não
+ * está na lista dele não existe para o modelo, por mais que o cliente saiba
+ * executá-la. Quando as duas listas divergem, o que a pessoa vê não tem nada
+ * a ver com a causa:
+ *
+ *   - "a ferramenta necessária não está disponível" — o modelo chamou um nome
+ *     que o servidor velho ainda oferece e que o cliente novo já não atende;
+ *   - "ele faz uma parte e para" — as chamadas falham, a dívida de falhas
+ *     pendentes nunca zera, e a tarefa morre em "parei sem concluir".
+ *
+ * Nenhuma dessas frases aponta para "o servidor está desatualizado", que é a
+ * única coisa acionável. O usuário passa a tarde achando que a IA é ruim.
+ *
+ * ── POR QUE A VERSÃO, E NÃO A LISTA DE FERRAMENTAS ───────────────────────
+ * Comparar as duas listas seria mais direto, mas o /health não as publica, e
+ * pedir a lista inteira a cada início de sessão custa mais do que informa. A
+ * versão é o que o /health já diz, e é suficiente: o contrato entre os dois
+ * repositórios muda junto com ela.
+ *
+ * ── O AVISO É UMA VEZ, E NÃO SEGURA NADA ─────────────────────────────────
+ * Ele sai no começo da sessão e some. Não bloqueia: o servidor velho ainda
+ * serve conversa, código e shell — o que ele não serve é o Estúdio. Travar a
+ * sessão inteira por causa disso trocaria um problema por um pior.
+ */
+
+'use strict';
+
+/**
+ * Compara "8.11.0" com "8.12.0". Devolve -1, 0 ou 1.
+ *
+ * Só os três números importam: um sufixo de pré-lançamento ("8.12.0-rc.1") é
+ * ignorado de propósito. Quem roda um rc sabe o que está fazendo, e tratá-lo
+ * como anterior ao 8.12.0 faria o aviso aparecer justamente para quem já
+ * está à frente.
+ */
+function compararVersao(a, b) {
+    const partes = (v) => String(v || '0').split('-')[0].split('.').map((n) => Number(n) || 0);
+    const x = partes(a);
+    const y = partes(b);
+    for (let i = 0; i < 3; i++) {
+        if ((x[i] || 0) > (y[i] || 0)) return 1;
+        if ((x[i] || 0) < (y[i] || 0)) return -1;
+    }
+    return 0;
+}
+
+/**
+ * O servidor atende este cliente?
+ *
+ * `saude` é a resposta do /health. Sem ela — rede fora, servidor dormindo no
+ * plano grátis — a resposta é "não sei", nunca "está velho": acusar o
+ * servidor porque a rede caiu manda a pessoa consertar o que não quebrou.
+ */
+function avaliar({ saude, minimo, servidor }) {
+    const versao = saude && typeof saude.version === 'string' ? saude.version : '';
+    if (!versao) return { ok: true, sabido: false };
+    if (compararVersao(versao, minimo) >= 0) return { ok: true, sabido: true, versao };
+
+    return {
+        ok: false,
+        sabido: true,
+        versao,
+        minimo,
+        titulo: `O servidor está na versão ${versao}, e este cliente precisa da ${minimo} ou maior.`,
+        detalhe: 'Enquanto ele não subir, o Estúdio (vídeo, slides, arte) e a transcrição de áudio '
+            + 'não funcionam: o servidor antigo oferece ao modelo ferramentas que este cliente já não '
+            + 'atende, e a tarefa morre no meio sem dizer por quê.',
+        comoResolver: servidor
+            ? `Confira com: curl -s ${servidor.replace(/\/+$/, '')}/health`
+            : 'Confira a versão em /health do servidor configurado.',
+    };
+}
+
+/** O aviso pronto para a tela, ou vazio quando não há o que avisar. */
+function aviso(r, cores) {
+    if (!r || r.ok) return '';
+    const c = cores || { warn: (t) => t, dim: (t) => t };
+    return [
+        c.warn('  ' + r.titulo),
+        c.dim('  ' + r.detalhe),
+        c.dim('  ' + r.comoResolver),
+    ].join('\n');
+}
+
+module.exports = { compararVersao, avaliar, aviso };

package/lib/conta.js

@@ -1,16 +1,23 @@
 /**
  * conta.js — entrar na conta Conecta Primo, de dentro do terminal.
  *
- *   "Quando você dá `primo`, ele vai abrir pra primeiro você fazer o login. E
- *    aí ele vai abrir lá o Conecta Primo AI pra você fazer o login, com algum
- *    token que ele gera automaticamente. Você faz o login ali e aparece uma
- *    confirmação na tela; ela até fecha sozinha depois de 5 segundos. Daí no
- *    terminal ele vai ver que você fez login, e se a sua conta for Premium ele
- *    libera pra você usar."
+ *   "Com /login você só entra na conta de novo, não tem mais ligar terminal
+ *    com o navegador." (23/09/2026)
  *
- * O desenho inteiro está no outro lado (backend/dispositivos.py do
- * conecta-primo-ai). Daqui o que importa é: pedir um código, abrir o navegador,
- * esperar, e guardar o que voltar.
+ * ── SEM NAVEGADOR, MESMO PROTOCOLO ───────────────────────────────────────
+ * O login era um pareamento: o terminal pedia um código, abria o navegador, a
+ * pessoa aprovava lá e o terminal esperava. Agora o terminal pergunta e-mail
+ * e senha e faz, ele mesmo, os três passos que a página fazia:
+ *
+ *   1. entra no Firebase com e-mail e senha (a mesma conta do app);
+ *   2. abre um pedido de dispositivo (`/api/dispositivo/novo`);
+ *   3. aprova esse pedido com o token do Firebase e recolhe o token `pc_`.
+ *
+ * O backend (backend/dispositivos.py do conecta-primo-ai) não muda nada: para
+ * ele, é uma aprovação como qualquer outra, e o `pc_` continua sendo a única
+ * credencial guardada. A senha e o token do Firebase não saem da memória.
+ *
+ * Conta criada só com o Google não tem senha, e não entra por aqui.
  *
  * ── O ARQUIVO DA CREDENCIAL ──────────────────────────────────────────────
  * Ele NÃO entra no config.json. Aquele arquivo guarda preferência — modo,
@@ -29,7 +36,6 @@ const os = require('os');
 const path = require('path');
 const https = require('https');
 const http = require('http');
-const area = require('./area.js');
 
 // O servidor do Conecta Primo — que NÃO é o servidor do PrimoCode. São dois
 // serviços diferentes: um responde o chat do app e a conta, o outro é o motor
@@ -38,14 +44,20 @@ const CONECTA = process.env.PRIMOCODE_CONTA_SERVER || 'https://conecta-primo-api
 
 const ARQUIVO = path.join(os.homedir(), '.primocode', 'conta.json');
 
+// O login com e-mail e senha é o do Firebase do Conecta Primo. A chave é a
+// PÚBLICA do app web (a mesma que vai no frontend, à vista de qualquer um):
+// ela identifica o projeto, não dá acesso a nada sem a senha da pessoa.
+const FIREBASE_CHAVE = process.env.PRIMOCODE_FIREBASE_API_KEY || 'AIzaSyAyaj994i9Hr2le8Q-4YxxkgJJnL2NtJLg';
+const FIREBASE_AUTH = process.env.PRIMOCODE_FIREBASE_AUTH_URL || 'https://identitytoolkit.googleapis.com/v1';
+
 // Os planos que liberam tudo. A lista é a MESMA do servidor
 // (`PLANOS_COM_PRO`), e quem decide de verdade é ele: isto aqui só evita uma
 // ida à rede para mostrar o selo na abertura.
 const PLANOS_PRO = ['premium', 'super'];
 
-function pedir(rota, corpo, timeout = 30000) {
+function pedir(rota, corpo, timeout = 30000, { token, base = CONECTA } = {}) {
     return new Promise((resolve, reject) => {
-        const url = new URL(CONECTA + rota);
+        const url = new URL(base + rota);
         const lib = url.protocol === 'https:' ? https : http;
         const dados = corpo == null ? null : Buffer.from(JSON.stringify(corpo), 'utf8');
         const cabecalhos = { Accept: 'application/json' };
@@ -53,7 +65,10 @@ function pedir(rota, corpo, timeout = 30000) {
             cabecalhos['Content-Type'] = 'application/json';
             cabecalhos['Content-Length'] = dados.length;
         }
-        const cred = ler();
+        // Quem chama pode mandar o token (o do Firebase, no login) ou `null`
+        // para ir SEM token nenhum — o pedido ao Firebase nunca pode levar o
+        // `pc_` guardado. Sem a opção, vai o da credencial guardada.
+        const cred = token !== undefined ? (token ? { token } : null) : ler();
         if (cred && cred.token) cabecalhos.Authorization = `Bearer ${cred.token}`;
 
         const req = lib.request({
@@ -106,93 +121,49 @@ function atual() {
 
 // ── entrar ───────────────────────────────────────────────────────────────
 
-/* ── O CÓDIGO CHEGA À PÁGINA SEM NINGUÉM DIGITAR ─────────────────────────
- *
- *   "No login quero que ele copie o código pra área de transferência
- *    automaticamente. A tela de login deve ter só o negócio pra verificar o
- *    código e ele já cola automaticamente o código."
- *
- * A regra da casa continua a mesma: O CÓDIGO NÃO VAI NO LINK. Com ele na URL,
- * um link mandado por outra pessoa conectaria o computador DELA à conta de
- * quem clicou. O que muda é COMO ele chega à página:
- *
- *   1. Enquanto espera a aprovação, o CLI serve `GET /pareamento` em
- *      127.0.0.1, e a página pergunta ali. Só uma página aberta NESTA máquina
- *      alcança 127.0.0.1 desta máquina — o que é mais seguro que digitar, não
- *      menos: o link do atacante abriria a página na máquina da vítima, cujo
- *      CLI (se estiver rodando) tem o código DA VÍTIMA, nunca o dele.
- *   2. O código também vai para a área de transferência: no Safari, que
- *      bloqueia http://127.0.0.1 a partir de página https, a página oferece
- *      "Colar" — um toque, sem ler oito letras.
- *   3. Se nada disso servir, a pessoa digita, como antes.
- *
- * A resposta do servidor local só sai com `Access-Control-Allow-Origin` para a
- * ORIGEM DO SITE (a que veio no `pedido.url`). Sem isso qualquer página aberta
- * no navegador poderia ler 127.0.0.1 e roubar o código para aprová-lo na
- * própria conta. A porta vai na URL (`?porta=`), e a porta não é segredo: ela
- * só diz ONDE perguntar, e quem não está nesta máquina não alcança.
- */
-const PORTA_PAREAMENTO = Number(process.env.PRIMOCODE_PORTA_PAREAMENTO) || 7799;
-
-function servirPareamento(codigo, origemDoSite) {
-    const permitidas = new Set([origemDoSite, 'http://127.0.0.1', 'http://localhost']
-        .filter(Boolean));
-    const permitida = (origem) => {
-        if (!origem) return false;
-        if (permitidas.has(origem)) return true;
-        // Os testes e a prévia local rodam em portas variadas de 127.0.0.1.
-        return /^http:\/\/(127\.0\.0\.1|localhost)(:\d+)?$/.test(origem);
-    };
-
-    const servidor = http.createServer((req, res) => {
-        const origem = req.headers.origin;
-        const cab = { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store' };
-        if (permitida(origem)) {
-            cab['Access-Control-Allow-Origin'] = origem;
-            cab.Vary = 'Origin';
-            cab['Access-Control-Allow-Methods'] = 'GET, OPTIONS';
-            cab['Access-Control-Allow-Private-Network'] = 'true';
-        }
-        if (req.method === 'OPTIONS') { res.writeHead(204, cab); return res.end(); }
-        const rota = (req.url || '/').split('?')[0];
-        if (rota !== '/pareamento' || req.method !== 'GET') {
-            res.writeHead(404, cab); return res.end('{"ok":false}');
-        }
-        // Sem origem permitida, a resposta sai SEM o cabeçalho CORS: o navegador
-        // recebe e descarta antes de a página ler. O corpo continua igual de
-        // propósito — o que protege é o cabeçalho, não esconder o corpo, e
-        // dois corpos diferentes seriam dois caminhos para manter.
-        res.writeHead(200, cab);
-        res.end(JSON.stringify({ ok: true, codigo, origem: `PrimoCode ${versao()}` }));
-    });
-
-    return new Promise((ok) => {
-        let porta = PORTA_PAREAMENTO;
-        const tentar = () => {
-            servidor.once('error', (e) => {
-                if (e.code === 'EADDRINUSE' && porta < PORTA_PAREAMENTO + 10) { porta++; tentar(); }
-                else ok({ porta: null, fechar: () => {} });   // sem servidor local: digita ou cola
-            });
-            servidor.listen(porta, '127.0.0.1', () => {
-                ok({ porta, fechar: () => { try { servidor.close(); } catch { /* já fechou */ } } });
-            });
-        };
-        tentar();
-    });
+/* O que o Firebase responde quando não entra → o que a pessoa lê. Os códigos
+   vêm no começo de `error.message` ("INVALID_PASSWORD : …"). */
+function erroDoFirebase(codigo) {
+    const c = String(codigo || '').split(/\s|:/)[0].toUpperCase();
+    if (/INVALID_LOGIN_CREDENTIALS|INVALID_PASSWORD|EMAIL_NOT_FOUND/.test(c)) {
+        return 'e-mail ou senha incorretos. Se você entra no app pelo Google, essa conta não tem senha para o terminal.';
+    }
+    if (c === 'INVALID_EMAIL') return 'esse e-mail não parece válido.';
+    if (c === 'USER_DISABLED') return 'essa conta está desativada.';
+    if (/TOO_MANY_ATTEMPTS/.test(c)) return 'muitas tentativas seguidas. Espere alguns minutos e tente de novo.';
+    if (c === 'MISSING_PASSWORD') return 'faltou a senha.';
+    return `o login recusou (${c || 'sem motivo'}).`;
 }
 
 /**
- * O login inteiro: pede o código, abre o navegador, espera a aprovação.
+ * O login inteiro, sem navegador: e-mail e senha → token `pc_` guardado.
  *
  * @param {object} op
- * @param {(url:string)=>any} op.abrir     abre o navegador (vem do tools.js)
- * @param {(info:object)=>void} [op.contar] recebe {url, codigo, copiado, porta} uma vez, antes de esperar
- * @param {number} [op.minutos]            teto da espera
+ * @param {string} op.email
+ * @param {string} op.senha
  */
-async function entrar({ abrir, contar = () => {}, minutos = 5 } = {}) {
+async function entrar({ email, senha } = {}) {
+    email = String(email || '').trim();
+    if (!email || !senha) return { ok: false, error: 'informe o e-mail e a senha.' };
+
+    // 1. Firebase: a mesma conta do app.
+    let fb;
+    try {
+        fb = await pedir(`/accounts:signInWithPassword?key=${encodeURIComponent(FIREBASE_CHAVE)}`,
+            { email, password: String(senha), returnSecureToken: true }, 20000,
+            { token: null, base: FIREBASE_AUTH });
+    } catch (e) {
+        return { ok: false, error: `não consegui falar com o login: ${e.message}` };
+    }
+    if (!fb || !fb.idToken) {
+        return { ok: false, error: erroDoFirebase(fb && fb.error && fb.error.message) };
+    }
+
+    // 2. O pedido de dispositivo, como o navegador abria.
     let pedido;
     try {
-        pedido = await pedir('/api/dispositivo/novo', { origem: `PrimoCode ${versao()}` });
+        pedido = await pedir('/api/dispositivo/novo', { origem: `PrimoCode ${versao()}` },
+            30000, { token: fb.idToken });
     } catch (e) {
         return { ok: false, error: `não consegui falar com o Conecta Primo: ${e.message}` };
     }
@@ -200,51 +171,27 @@ async function entrar({ abrir, contar = () => {}, minutos = 5 } = {}) {
         return { ok: false, error: (pedido && pedido.error) || 'o servidor recusou abrir o login' };
     }
 
-    let origemDoSite = null;
-    try { origemDoSite = new URL(pedido.url).origin; } catch { /* url estranha: sem CORS para ela */ }
-    const local = await servirPareamento(pedido.codigo, origemDoSite);
-    const copiado = await area.copiar(pedido.codigo);
-
-    let url = pedido.url;
-    if (local.porta) url += (url.includes('?') ? '&' : '?') + 'porta=' + local.porta;
-
-    contar({ url, codigo: pedido.codigo, copiado: copiado.ok, porta: local.porta });
-    if (abrir) { try { await abrir(url); } catch { /* segue: o link está na tela */ } }
-
+    // 3. Aprovar com o token do Firebase e recolher o `pc_`. O apelido é o que
+    //    aparece na lista de computadores da conta.
     try {
-        /* A espera. Dois segundos entre perguntas: mais rápido é marteladas no
-           servidor por uma pessoa que ainda está digitando a senha; mais devagar e
-           o terminal parece travado depois de a página já ter confirmado. */
-        const prazo = Date.now() + minutos * 60000;
-        while (Date.now() < prazo) {
-            await new Promise((ok) => setTimeout(ok, 2000));
-            let r;
-            try {
-                r = await pedir('/api/dispositivo/consultar',
-                    { codigo: pedido.codigo, segredo: pedido.segredo }, 10000);
-            } catch { continue; }          // rede tropeçou: pergunta de novo
-            if (!r || !r.success) continue;
-            if (r.estado === 'expirado') {
-                return { ok: false, error: 'o código venceu antes de você aprovar. Tente de novo.' };
-            }
-            if (r.estado !== 'aprovado') continue;
-
-            gravar({
-                token: r.token, uid: r.uid, plano: r.plano || 'free',
-                desde: new Date().toISOString(), servidor: CONECTA,
-            });
-            /* Aprovou lá: a atenção da pessoa está no navegador. O sino e o foco
-               trazem-na de volta — o foco só no macOS, e o módulo diz por quê. */
-            area.apitar();
-            const volta = area.voltarAoTerminal();
-            return { ok: true, uid: r.uid, plano: r.plano,
-                pro: PLANOS_PRO.includes(r.plano), voltou: !!volta.ok };
+        const ap = await pedir('/api/dispositivo/aprovar',
+            { codigo: pedido.codigo, apelido: `PrimoCode · ${os.hostname()}`.slice(0, 60) },
+            30000, { token: fb.idToken });
+        if (!ap || !ap.success) {
+            return { ok: false, error: (ap && ap.error) || 'o servidor recusou aprovar o login' };
+        }
+        const r = await pedir('/api/dispositivo/consultar',
+            { codigo: pedido.codigo, segredo: pedido.segredo }, 30000, { token: null });
+        if (!r || !r.success || r.estado !== 'aprovado' || !r.token) {
+            return { ok: false, error: (r && r.error) || 'o login não foi concluído. Tente de novo.' };
         }
-        return { ok: false, error: `passaram ${minutos} minutos sem aprovação. Rode /connect de novo.` };
-    } finally {
-        // O servidor local só existe durante a espera. Deixá-lo de pé seria
-        // uma porta respondendo um código morto para sempre.
-        local.fechar();
+        gravar({
+            token: r.token, uid: r.uid, plano: r.plano || 'free', email,
+            desde: new Date().toISOString(), servidor: CONECTA,
+        });
+        return { ok: true, uid: r.uid, plano: r.plano, pro: PLANOS_PRO.includes(r.plano) };
+    } catch (e) {
+        return { ok: false, error: `não consegui concluir o login: ${e.message}` };
     }
 }
 
@@ -287,4 +234,4 @@ function versao() {
     try { return require('../package.json').version; } catch { return '?'; }
 }
 
-module.exports = { entrar, sair, atual, sessao, dispositivos, servirPareamento, ARQUIVO, CONECTA, PLANOS_PRO, PORTA_PAREAMENTO };
+module.exports = { entrar, sair, atual, sessao, dispositivos, erroDoFirebase, ARQUIVO, CONECTA, PLANOS_PRO };

package/lib/entrada.js

@@ -218,6 +218,7 @@ class Entrada extends EventEmitter {
         this.ocupado = false;
         this.fechado = false;
         this.colando = false;
+        this.oculto = false;      // a próxima resposta é senha: ver `ocultarProxima`
         this.tty = !!(process.stdin.isTTY && process.stdout.isTTY);
         this.escreverCru = process.stdout.write.bind(process.stdout);
     }
@@ -341,14 +342,21 @@ class Entrada extends EventEmitter {
 
     limpar() { this.line = ''; this.cursor = 0; this.menu = null; this._mudou(); }
 
+    /**
+     * A PRÓXIMA linha é senha: a caixa desenha `•` no lugar das letras, não
+     * repete o texto na tela ao enviar e não o guarda no histórico — senão a
+     * seta para cima devolveria a senha. Vale para uma linha só.
+     */
+    ocultarProxima() { this.oculto = true; this.menu = null; this._mudou(); }
+
     // ── desenho ──────────────────────────────────────────────────────────
 
     _quadro() {
         return montar({
-            texto: this.line,
+            texto: this.oculto ? '•'.repeat(this.line.length) : this.line,
             cursor: this.cursor,
             colunas: process.stdout.columns || 80,
-            fantasma: this._fantasma(),
+            fantasma: this.oculto ? '' : this._fantasma(),
             vazio: this.op.vazio || '',
             status: this.op.status ? this.op.status() : [],
             menu: this.menu,
@@ -408,6 +416,7 @@ class Entrada extends EventEmitter {
     }
 
     _filtrarMenu() {
+        if (this.oculto) { this.menu = null; return; }
         const lista = this.op.comandos ? this.op.comandos() : [];
         const baixa = this.line.toLowerCase();
         const itens = this.line.startsWith('/') && !/\s/.test(this.line)
@@ -575,6 +584,8 @@ class Entrada extends EventEmitter {
     _enviar() {
         if (this.menu) return this._escolherDoMenu();
         const texto = this.line;
+        const oculto = this.oculto;
+        this.oculto = false;
         this.line = '';
         this.cursor = 0;
         this.menu = null;
@@ -584,7 +595,7 @@ class Entrada extends EventEmitter {
            senão o pedido some no instante em que a resposta começa, e quem
            rola para cima não acha o que perguntou. */
         this._apagar();
-        if (texto.trim()) {
+        if (texto.trim() && !oculto) {
             const marca = c.brand('❯ ');
             this.escreverCru(texto.split('\n').map((l, i) => (i ? '  ' : marca) + c.white(l)).join('\n') + '\n');
             if (this.historico[this.historico.length - 1] !== texto) this.historico.push(texto);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.3.0",
+  "version": "9.4.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/skills.test.js && node test/estudio.test.js && node test/voz.test.js && node test/modo.test.js && node test/pasta.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/pareamento.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/estudio.test.js && node test/voz.test.js && node test/modo.test.js && node test/pasta.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js"
   },
   "engines": {
     "node": ">=18.17.0"
@@ -39,5 +39,8 @@
     "!studio/arquivos",
     "!studio/midia",
     "!studio/saida"
-  ]
+  ],
+  "primocode": {
+    "servidorMinimo": "8.12.0"
+  }
 }

package/lib/area.js

@@ -1,104 +0,0 @@
-/**
- * area.js — a área de transferência e o foco do terminal, sem dependência.
- *
- *   "No login quero que ele copie o código pra área de transferência
- *    automaticamente. [...] Ele libera, você volta ao terminal
- *    automaticamente."
- *
- * ── POR QUE FALAR COM O SISTEMA, E NÃO COM UM PACOTE ────────────────────
- * O CLI tem zero dependências e isto não é motivo para abrir a primeira: todo
- * sistema já tem um programa que escreve na área de transferência (pbcopy,
- * clip, wl-copy, xclip, xsel). O que este módulo faz é achar qual existe e
- * falar com ele — e FALHAR EM SILÊNCIO quando nenhum existe, porque copiar é
- * conveniência: o código continua na tela e a página continua aceitando
- * digitação. Conveniência que derruba o login não é conveniência.
- *
- * ── O FOCO SÓ VOLTA NO MAC, E É HONESTO DIZER ────────────────────────────
- * Trazer o terminal para a frente depois de a página aprovar é o que fecha o
- * laço "clicou → voltou". No macOS dá: o `TERM_PROGRAM` diz qual app é o
- * terminal e o `osascript` o ativa. No Windows e no Linux não há um jeito
- * geral que funcione sem depender do gerenciador de janelas — então lá o CLI
- * apita e imprime o próximo passo, e a janela do navegador diz "volte ao
- * terminal". Prometer o foco onde ele não vem seria pior que não prometer.
- */
-
-'use strict';
-
-const os = require('os');
-const { execFile, execFileSync } = require('child_process');
-
-/* Cada candidato é [programa, argumentos]. A ordem dentro de cada sistema é
-   a do que existe com mais frequência: no Linux o Wayland vem primeiro
-   porque, quando ele é a sessão, o xclip existe e NÃO funciona. */
-function candidatos() {
-    const p = os.platform();
-    if (p === 'darwin') return [['pbcopy', []]];
-    if (p === 'win32') return [['clip', []]];
-    const lista = [];
-    if (process.env.WAYLAND_DISPLAY) lista.push(['wl-copy', []]);
-    lista.push(['xclip', ['-selection', 'clipboard']], ['xsel', ['--clipboard', '--input']]);
-    if (!process.env.WAYLAND_DISPLAY) lista.push(['wl-copy', []]);
-    return lista;
-}
-
-/**
- * Copia o texto para a área de transferência.
- * @returns {Promise<{ok:boolean, como?:string}>}  nunca rejeita
- */
-function copiar(texto) {
-    const fila = candidatos();
-    return new Promise((resolve) => {
-        const tentar = (i) => {
-            if (i >= fila.length) return resolve({ ok: false });
-            const [cmd, args] = fila[i];
-            let filho;
-            try {
-                filho = execFile(cmd, args, { timeout: 3000, windowsHide: true }, (erro) => {
-                    if (erro) return tentar(i + 1);
-                    resolve({ ok: true, como: cmd });
-                });
-            } catch { return tentar(i + 1); }
-            filho.on('error', () => tentar(i + 1));
-            try { filho.stdin.on('error', () => {}); filho.stdin.end(String(texto)); }
-            catch { tentar(i + 1); }
-        };
-        tentar(0);
-    });
-}
-
-/* O app do terminal, pelo que ele mesmo declara. Os cinco da lista são os que
-   têm nome de aplicativo diferente do valor da variável — os outros
-   (Warp, Alacritty, kitty, Ghostty) já se chamam pelo próprio nome. */
-const APPS_MAC = {
-    Apple_Terminal: 'Terminal',
-    'iTerm.app': 'iTerm',
-    vscode: 'Visual Studio Code',
-    Hyper: 'Hyper',
-    WezTerm: 'WezTerm',
-};
-
-/**
- * Traz o terminal de volta para a frente. Só faz algo no macOS; nos outros
- * sistemas devolve {ok:false, motivo} sem tentar nada.
- */
-function voltarAoTerminal() {
-    if (os.platform() !== 'darwin') return { ok: false, motivo: 'só no macOS' };
-    const programa = process.env.TERM_PROGRAM || '';
-    const app = APPS_MAC[programa] || programa.replace(/\.app$/, '');
-    if (!app) return { ok: false, motivo: 'terminal não se identificou' };
-    try {
-        // O nome vai como ARGUMENTO do AppleScript, nunca dentro do texto do
-        // script: TERM_PROGRAM é ambiente, e ambiente é o que qualquer coisa
-        // escreve.
-        execFileSync('osascript', ['-e', 'on run argv', '-e', 'tell application (item 1 of argv) to activate',
-            '-e', 'end run', app], { timeout: 3000, stdio: 'ignore' });
-        return { ok: true, app };
-    } catch { return { ok: false, motivo: 'osascript recusou' }; }
-}
-
-/** O sino do terminal: chama a atenção de quem está olhando o navegador. */
-function apitar() {
-    try { if (process.stdout.isTTY) process.stdout.write('\x07'); } catch { /* sem tty */ }
-}
-
-module.exports = { copiar, voltarAoTerminal, apitar, candidatos, APPS_MAC };