primocode 10.7.0 → 10.8.0

package/lib/conta.js

@@ -1,32 +1,30 @@
 /**
- * conta.js — entrar na conta Conecta Primo, de dentro do terminal.
+ * conta.js — a conta do PrimoCode, no Firebase do próprio PrimoCode.
  *
- *   "Com /login você só entra na conta de novo, não tem mais ligar terminal
- *    com o navegador." (23/09/2026)
+ *   "não vai mais precisar conecta … conta no Primo Code … Firebase …
+ *    redefinir senha … plano obrigatoriamente" (Joel, 12/10/2026)
  *
- * ── 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:
+ * ── O LOGIN ──────────────────────────────────────────────────────────────
+ * `/login` abre o navegador em primocode.web.app/entrar. Lá a pessoa cria a
+ * conta, entra ou redefine a senha. A página devolve o login para o terminal
+ * por um formulário enviado a http://127.0.0.1:<porta>/pronto (uma navegação,
+ * não um fetch: o navegador não barra página pública falando com o
+ * localhost por navegação). O `estado` aleatório impede outra página de
+ * empurrar um login que o terminal não pediu.
  *
- *   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_`.
+ * Sem navegador (SSH, servidor): `/login senha` pergunta e-mail e senha aqui.
  *
- * 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.
+ * ── A CREDENCIAL ─────────────────────────────────────────────────────────
+ * Fica o refresh token do Firebase e o token de acesso da hora (1h). O de
+ * acesso vai ao servidor do PrimoCode no `x-primocode-token`, que confere a
+ * assinatura com as chaves do Google, sem perguntar a ninguém. Mora em
+ * `~/.primocode/conta.json` (600), NUNCA no config.json: aquele é o arquivo
+ * que alguém cola num chamado de suporte.
  *
- * 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,
- * esforço, mascote — e é o que alguém abre para conferir um ajuste, cola num
- * chamado de suporte ou copia para outra máquina. Credencial junto de
- * preferência é credencial que vaza por hábito, não por ataque.
- *
- * Mora em `~/.primocode/conta.json`, com permissão 600 onde o sistema tem
- * permissão (no Windows o modo é ignorado, e está dito no comentário de lá).
+ * ── O PLANO ──────────────────────────────────────────────────────────────
+ * Mora em users/{uid} no Firestore (plano, planoAte), escrito só pelo
+ * servidor quando o pagamento cai. O terminal lê com o token da pessoa; o
+ * arquivo local guarda a última leitura só para o selo da abertura.
  */
 
 'use strict';
@@ -34,67 +32,37 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const https = require('https');
 const http = require('http');
-
-// 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
-// do agente. Confundir os dois dá "não autenticado" sem explicação.
-const CONECTA = process.env.PRIMOCODE_CONTA_SERVER || 'https://conecta-primo-api.onrender.com';
+const crypto = require('crypto');
+const { spawn } = require('child_process');
 
 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'];
-/* ASSINANTE É QUEM NÃO ESTÁ NO GRÁTIS (11/10). A conta do Joel veio do Conecta
-   como "empresarial" — um plano pago que esta lista não conhecia — e ele caiu
-   no limite de quem não paga, com a mensagem "assine o Premium". O Conecta cria
-   plano novo sem avisar o PrimoCode; o que não muda é o nome do grátis. */
-const PLANOS_GRATIS = ['free', 'gratis', 'grátis', 'gratuito', 'basico', 'básico', ''];
-const ehPago = (plano) => !PLANOS_GRATIS.includes(String(plano == null ? '' : plano).trim().toLowerCase());
-
-function pedir(rota, corpo, timeout = 30000, { token, base = CONECTA } = {}) {
-    return new Promise((resolve, reject) => {
-        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' };
-        if (dados) {
-            cabecalhos['Content-Type'] = 'application/json';
-            cabecalhos['Content-Length'] = dados.length;
-        }
-        // 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({
-            hostname: url.hostname, port: url.port || undefined,
-            path: url.pathname + url.search,
-            method: dados ? 'POST' : 'GET', timeout, headers: cabecalhos,
-        }, (res) => {
-            let texto = '';
-            res.setEncoding('utf8');
-            res.on('data', (c) => { texto += c; });
-            res.on('end', () => {
-                try { resolve(JSON.parse(texto)); }
-                catch { reject(new Error(`resposta inesperada do servidor (${res.statusCode})`)); }
-            });
-        });
-        req.on('timeout', () => req.destroy(new Error('o servidor demorou demais')));
-        req.on('error', reject);
-        if (dados) req.write(dados);
-        req.end();
-    });
+/* PÚBLICA: identifica o projeto, não dá acesso a nada sem a senha da pessoa
+   (quem decide o que cada um faz são as regras do Firestore). */
+const FIREBASE_CHAVE = process.env.PRIMOCODE_FIREBASE_API_KEY || 'AIzaSyBrzCAbG4AilaDyiOcJI0R1il_aldOxUsg';
+const PROJETO = process.env.PRIMOCODE_FIREBASE_PROJETO || 'primocode';
+const IDENTIDADE = process.env.PRIMOCODE_FIREBASE_AUTH_URL || 'https://identitytoolkit.googleapis.com/v1';
+const RENOVAR = process.env.PRIMOCODE_FIREBASE_TOKEN_URL || 'https://securetoken.googleapis.com/v1';
+const FIRESTORE = process.env.PRIMOCODE_FIRESTORE || 'https://firestore.googleapis.com';
+const SITE = process.env.PRIMOCODE_SITE || 'https://primocode.web.app';
+
+/* Os planos pagos, com os nomes antigos do Conecta ainda valendo. A lista
+   de verdade é a do servidor (lib/planos.js de lá); esta só desenha o selo. */
+const PLANOS_PAGOS = ['primo', 'pro', 'max', 'studio', 'premium', 'super', 'empresarial'];
+const ehPago = (plano, ate) => PLANOS_PAGOS.includes(String(plano == null ? '' : plano).trim().toLowerCase())
+    && (!ate || new Date(ate).getTime() > Date.now());
+
+async function json(url, { metodo = 'POST', corpo, cabecalhos = {}, form = false, buscar = fetch } = {}) {
+    const op = { method: metodo, headers: { Accept: 'application/json', ...cabecalhos } };
+    if (corpo != null) {
+        op.headers['Content-Type'] = form ? 'application/x-www-form-urlencoded' : 'application/json';
+        op.body = form ? new URLSearchParams(corpo).toString() : JSON.stringify(corpo);
+    }
+    const r = await buscar(url, { ...op, signal: AbortSignal.timeout(20000) });
+    let j = {};
+    try { j = await r.json(); } catch { /* pode vir vazio */ }
+    return { ok: r.ok, status: r.status, j: j || {} };
 }
 
 // ── o arquivo ────────────────────────────────────────────────────────────
@@ -106,9 +74,8 @@ function ler() {
 
 function gravar(dados) {
     fs.mkdirSync(path.dirname(ARQUIVO), { recursive: true });
-    fs.writeFileSync(ARQUIVO, JSON.stringify(dados, null, 2), 'utf8');
-    // 600 = só o dono lê. No Windows o modo é ignorado pelo sistema de
-    // arquivos e a chamada não falha — lá quem protege é a pasta do perfil.
+    fs.writeFileSync(ARQUIVO, JSON.stringify(dados, null, 2), { encoding: 'utf8', mode: 0o600 });
+    // No Windows o modo é ignorado e a chamada não falha: lá protege a pasta do perfil.
     try { fs.chmodSync(ARQUIVO, 0o600); } catch {}
 }
 
@@ -117,127 +84,185 @@ function sair() {
     catch { return false; }
 }
 
-/** Quem está conectado, sem ir à rede. */
+/** Quem está conectado, sem ir à rede. A credencial antiga do Conecta (`pc_`) não vale mais. */
 function atual() {
     const c = ler();
-    if (!c || !c.token) return null;
-    return { uid: c.uid, plano: c.plano || 'free', email: c.email || null,
-        pro: ehPago(c.plano), desde: c.desde };
+    if (!c || !c.refreshToken || !c.uid) return null;
+    return { uid: c.uid, email: c.email || null, plano: c.plano || 'free', planoAte: c.planoAte || null,
+        pro: ehPago(c.plano, c.planoAte), desde: c.desde };
 }
 
-// ── entrar ───────────────────────────────────────────────────────────────
+/** Sobrou a credencial do Conecta? Então a pessoa precisa entrar de novo, e vale dizer por quê. */
+function doConectaAntigo() {
+    const c = ler();
+    return !!(c && c.token && !c.refreshToken);
+}
+
+// ── os tokens ────────────────────────────────────────────────────────────
 
 /* 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.';
+        return `e-mail ou senha incorretos. Esqueceu a senha? ${SITE}/entrar#esqueci`;
     }
     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.';
+    if (/TOKEN_EXPIRED|INVALID_REFRESH_TOKEN|USER_NOT_FOUND/.test(c)) return 'a sessão venceu. Entre de novo com /login.';
     return `o login recusou (${c || 'sem motivo'}).`;
 }
 
+/** Guarda um login novo (vindo do navegador ou da senha) e já lê o plano. */
+async function guardarLogin({ refreshToken, idToken, uid, email, expiraEm }, op = {}) {
+    gravar({ uid, email: email || null, refreshToken, idToken: idToken || null,
+        expira: idToken ? Date.now() + (Number(expiraEm) || 3600) * 1000 : 0,
+        plano: 'free', planoAte: null, desde: new Date().toISOString() });
+    const p = await lerPlano(op);
+    const plano = p.ok ? p.plano : 'free';
+    return { ok: true, uid, email, plano, pro: ehPago(plano, p.planoAte) };
+}
+
 /**
- * O login inteiro, sem navegador: e-mail e senha → token `pc_` guardado.
- *
- * @param {object} op
- * @param {string} op.email
- * @param {string} op.senha
+ * O token de acesso válido por pelo menos mais 5 minutos (renova se precisar).
+ * Devolve null se não há conta, e apaga a credencial se o Firebase disser que ela morreu.
  */
-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;
+async function tokenValido({ buscar = fetch, forcar = false } = {}) {
+    const c = ler();
+    if (!c || !c.refreshToken) return null;
+    if (!forcar && c.idToken && Date.now() < (c.expira || 0) - 300000) return c.idToken;
+    let r;
     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) };
+        r = await json(`${RENOVAR}/token?key=${encodeURIComponent(FIREBASE_CHAVE)}`,
+            { corpo: { grant_type: 'refresh_token', refresh_token: c.refreshToken }, form: true, buscar });
+    } catch { return c.idToken || null; }   // sem rede: o servidor responde se ainda vale
+    if (!r.ok || !r.j.id_token) {
+        const m = r.j.error && (r.j.error.message || r.j.error);
+        if (/TOKEN_EXPIRED|INVALID_REFRESH_TOKEN|USER_NOT_FOUND|USER_DISABLED/.test(String(m))) sair();
+        return null;
     }
+    gravar({ ...c, idToken: r.j.id_token, refreshToken: r.j.refresh_token || c.refreshToken,
+        expira: Date.now() + (Number(r.j.expires_in) || 3600) * 1000 });
+    return r.j.id_token;
+}
 
-    // 2. O pedido de dispositivo, como o navegador abria.
-    let pedido;
-    try {
-        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}` };
-    }
-    if (!pedido || !pedido.success) {
-        return { ok: false, error: (pedido && pedido.error) || 'o servidor recusou abrir o login' };
+let relogio = null;
+/* Na abertura e a cada minuto: o token dura uma hora, e o config lê o do
+   arquivo a cada pedido. Depois do notebook dormir, no máximo um minuto de atraso. */
+async function manterVivo() {
+    await tokenValido().catch(() => null);
+    if (!relogio) {
+        relogio = setInterval(() => { tokenValido().catch(() => null); }, 60000);
+        relogio.unref();
     }
+}
+
+// ── o plano ──────────────────────────────────────────────────────────────
 
-    // 3. Aprovar com o token do Firebase e recolher o `pc_`. O apelido é o que
-    //    aparece na lista de computadores da conta.
+async function lerPlano({ buscar = fetch } = {}) {
+    const token = await tokenValido({ buscar });
+    const c = ler();
+    if (!token || !c) return { ok: false, error: 'não conectado' };
+    let r;
     try {
-        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.' };
-        }
-        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: ehPago(r.plano) };
-    } catch (e) {
-        return { ok: false, error: `não consegui concluir o login: ${e.message}` };
-    }
+        r = await json(`${FIRESTORE}/v1/projects/${PROJETO}/databases/(default)/documents/users/${encodeURIComponent(c.uid)}`,
+            { metodo: 'GET', cabecalhos: { Authorization: `Bearer ${token}` }, buscar });
+    } catch (e) { return { ok: false, error: e.message, offline: true }; }
+    if (r.status === 404) return { ok: true, plano: 'free', planoAte: null };   // conta nova, sem documento ainda
+    if (!r.ok) return { ok: false, error: `não consegui ler o plano (HTTP ${r.status})` };
+    const f = r.j.fields || {};
+    const plano = (f.plano && f.plano.stringValue) || 'free';
+    const planoAte = (f.planoAte && f.planoAte.timestampValue) || null;
+    if (plano !== c.plano || planoAte !== c.planoAte) gravar({ ...ler(), plano, planoAte });
+    return { ok: true, plano, planoAte };
 }
 
 /**
- * Confirma o plano no SERVIDOR e devolve a sessão para o Firestore.
- *
- * O plano guardado no arquivo é uma fotografia do dia do login: quem assinou
- * ontem continuaria como gratuito, e quem cancelou continuaria Premium. Quem
- * sabe é o servidor, e é ele quem diz — o arquivo local serve para mostrar o
- * selo na abertura sem esperar a rede, e só.
+ * Confirma o plano e devolve a sessão (o uid e o token) para o Firestore.
+ * O plano guardado é a foto do último login; quem sabe é o documento.
  */
-async function sessao() {
+async function sessao(op = {}) {
     const c = ler();
-    if (!c || !c.token) return { ok: false, error: 'não conectado' };
-    let r;
-    try { r = await pedir('/api/primocode/sessao', {}); }
-    catch (e) { return { ok: false, error: e.message, offline: true }; }
-    if (!r || !r.success) {
-        // Token revogado no painel, ou vencido: o arquivo local não vale mais.
-        // Apagar aqui evita a pessoa ficar vendo "conectado" para sempre com
-        // uma credencial morta.
-        if (r && /autenticado/i.test(r.error || '')) sair();
-        return { ok: false, error: (r && r.error) || 'o servidor recusou a sessão' };
+    if (!c || !c.refreshToken) return { ok: false, error: 'não conectado' };
+    const p = await lerPlano(op);
+    if (!p.ok) {
+        if (!ler()) return { ok: false, error: 'a sessão venceu. Entre de novo com /login.' };
+        return { ok: false, error: p.error, offline: !!p.offline };
     }
-    // O plano volta atualizado: grava por cima, senão o selo da abertura
-    // continua mostrando o de ontem.
-    if (r.plano && r.plano !== c.plano) gravar({ ...c, plano: r.plano });
-    return { ok: true, uid: r.uid, plano: r.plano, pro: !!r.pro,
-        customToken: r.custom_token, apiKey: r.api_key, projeto: r.projeto };
+    const agora = ler();
+    return { ok: true, uid: agora.uid, email: agora.email, plano: p.plano, planoAte: p.planoAte,
+        pro: ehPago(p.plano, p.planoAte), idToken: agora.idToken, projeto: PROJETO };
+}
+
+// ── entrar ───────────────────────────────────────────────────────────────
+
+/** Sem navegador: e-mail e senha aqui mesmo. */
+async function entrar({ email, senha } = {}, op = {}) {
+    email = String(email || '').trim();
+    if (!email || !senha) return { ok: false, error: 'informe o e-mail e a senha.' };
+    let r;
+    try {
+        r = await json(`${IDENTIDADE}/accounts:signInWithPassword?key=${encodeURIComponent(FIREBASE_CHAVE)}`,
+            { corpo: { email, password: String(senha), returnSecureToken: true }, buscar: op.buscar });
+    } catch (e) { return { ok: false, error: `não consegui falar com o login: ${e.message}` }; }
+    if (!r.ok || !r.j.idToken) return { ok: false, error: erroDoFirebase(r.j.error && r.j.error.message) };
+    return guardarLogin({ refreshToken: r.j.refreshToken, idToken: r.j.idToken, uid: r.j.localId,
+        email: r.j.email || email, expiraEm: r.j.expiresIn }, op);
 }
 
-/** Os computadores conectados nesta conta. */
-async function dispositivos() {
-    const r = await pedir('/api/primocode/dispositivos').catch((e) => ({ error: e.message }));
-    if (!r || !r.success) return { ok: false, error: (r && r.error) || 'não deu para listar' };
-    return { ok: true, dispositivos: r.dispositivos || [] };
+function abrirNoNavegador(url) {
+    const [cmd, args] = process.platform === 'darwin' ? ['open', [url]]
+        : process.platform === 'win32' ? ['cmd', ['/c', 'start', '""', url]]
+            : ['xdg-open', [url]];
+    try { spawn(cmd, args, { stdio: 'ignore', detached: true }).on('error', () => {}).unref(); return true; }
+    catch { return false; }
 }
 
-function versao() {
-    try { return require('../package.json').version; } catch { return '?'; }
+const PAGINA = (titulo, texto) => `<!doctype html><meta charset="utf-8"><title>PrimoCode</title><link rel="icon" href="data:,">
+<style>body{font:16px system-ui;background:#0b0b10;color:#eee;display:grid;place-items:center;height:100vh;margin:0}
+main{text-align:center;max-width:28rem;padding:1rem}h1{font-size:1.4rem}</style>
+<main><h1>${titulo}</h1><p>${texto}</p></main>`;
+
+/**
+ * Pelo navegador: abre o site, espera o formulário voltar no localhost.
+ * @param {{abrir?:(url:string)=>any, aviso?:(url:string)=>void, prazo?:number, buscar?:Function}} op
+ */
+function entrarPeloNavegador({ abrir = abrirNoNavegador, aviso = () => {}, prazo = 10 * 60000, buscar } = {}) {
+    const estado = crypto.randomBytes(16).toString('hex');
+    return new Promise((resolve) => {
+        let acabou = false;
+        const fim = (r) => { if (acabou) return; acabou = true; clearTimeout(timer); srv.close(); resolve(r); };
+        const srv = http.createServer((req, res) => {
+            if (req.method !== 'POST' || !req.url.startsWith('/pronto')) { res.statusCode = 404; return res.end(); }
+            let corpo = '';
+            req.on('data', (c) => { corpo += c; if (corpo.length > 20000) req.destroy(); });
+            req.on('end', async () => {
+                const f = new URLSearchParams(corpo);
+                res.setHeader('Content-Type', 'text/html; charset=utf-8');
+                if (f.get('estado') !== estado || !f.get('refreshToken') || !f.get('uid')) {
+                    res.statusCode = 400;
+                    return res.end(PAGINA('Esse login não é deste terminal', 'Volte ao terminal e rode /login de novo.'));
+                }
+                res.end(PAGINA('Pronto, você entrou ✓', 'Pode fechar esta aba e voltar ao terminal.'));
+                try {
+                    fim(await guardarLogin({ refreshToken: f.get('refreshToken'), idToken: f.get('idToken'),
+                        uid: f.get('uid'), email: f.get('email'), expiraEm: 3600 }, { buscar }));
+                } catch (e) { fim({ ok: false, error: e.message }); }
+            });
+        });
+        const timer = setTimeout(() => fim({ ok: false, error: 'o login no navegador não voltou em 10 minutos. Rode /login de novo.' }), prazo);
+        srv.on('error', (e) => fim({ ok: false, error: `não consegui abrir a porta do login: ${e.message}` }));
+        srv.listen(0, '127.0.0.1', () => {
+            const url = `${SITE}/entrar?porta=${srv.address().port}&estado=${estado}`;
+            aviso(url);
+            abrir(url);
+        });
+    });
 }
 
-module.exports = { entrar, sair, atual, sessao, dispositivos, erroDoFirebase, ARQUIVO, CONECTA, PLANOS_PRO, PLANOS_GRATIS, ehPago };
+module.exports = {
+    entrar, entrarPeloNavegador, sair, atual, sessao, lerPlano, tokenValido, manterVivo, doConectaAntigo,
+    erroDoFirebase, ehPago, ARQUIVO, SITE, PROJETO, FIREBASE_CHAVE, PLANOS_PAGOS,
+};

package/lib/estudio/conferencia.js

@@ -0,0 +1,98 @@
+/**
+ * conferencia.js — a conferência do vídeo PRONTO: o arquivo, medido, e não
+ * o plano.
+ *
+ *   "gostei, ficou bom. mas ainda não. tá quase lá" (Joel, 11/10)
+ *
+ * O revisor.js olha o plano antes do render. Este olha o .mp4 que saiu, e
+ * troca o "quase lá" no olho por número que se confere sem abrir o vídeo
+ * (a ideia veio do review.mjs do cth9191/animate, MIT):
+ *
+ *   som      volume integrado (LUFS), variação (LRA) e pico verdadeiro, pelo
+ *            ebur128 do ffmpeg. Alvo: -14 LUFS (±2) e pico até -1 dBTP.
+ *   parado   trecho em que a imagem não muda por 2 s ou mais, pelo
+ *            freezedetect, com o quadro reduzido a 320 px. Calibrado em 13/10
+ *            em 5 vídeos: na resolução cheia o ruído do fundo esconde a tela
+ *            parada; a 160 px o texto fica pequeno demais e a palavra que
+ *            entra não conta como mudança. A 320 px o teste-10-5-motion-com-
+ *            imagem dá 6,5 s a 8,3 s ("torrado" parado, a pílula vazia, e
+ *            para quando "café" entra), e os vídeos 3D não dão nada.
+ *
+ * Só mede e avisa. Não conserta nada: quem decide se refaz é o agente.
+ * As duas leituras (lerSom, lerParados) são puras e testáveis sem vídeo.
+ */
+
+'use strict';
+
+const video = require('./video.js');
+
+const ALVO = { lufs: -14, folgaLufs: 2, picoMax: -1, paradoMin: 2 };
+const r1 = (n) => Math.round(n * 10) / 10;
+
+/* O ebur128 escreve uma linha a cada 100 ms e um resumo no fim. Só o resumo
+   vale: a última linha "I:" de antes dele é a média até ali, não do vídeo. */
+function lerSom(texto) {
+    const t = String(texto || '');
+    const i = t.lastIndexOf('Summary:');
+    if (i < 0) return null;
+    const resumo = t.slice(i);
+    const num = (re) => { const m = resumo.match(re); return m ? Number(m[1]) : null; };
+    const lufs = num(/I:\s*(-?[\d.]+|-inf)\s*LUFS/);
+    if (lufs == null) return null;
+    return { lufs, lra: num(/LRA:\s*(-?[\d.]+)\s*LU\b/), pico: num(/Peak:\s*(-?[\d.]+)\s*dBFS/) };
+}
+
+/* O freezedetect marca o começo e o fim de cada trecho parado. Um começo
+   sem fim é tela parada até o último quadro. Dois trechos colados (o texto
+   some e o fundo fica) são, na tela, uma parada só. */
+function lerParados(texto, duracao) {
+    const trechos = [];
+    const juntar = (de, ate) => {
+        const ultimo = trechos[trechos.length - 1];
+        if (ultimo && de - ultimo.ate < 0.2) ultimo.ate = r1(ate);
+        else trechos.push({ de: r1(de), ate: r1(ate) });
+    };
+    let de = null;
+    for (const linha of String(texto || '').split('\n')) {
+        const i = linha.match(/freeze_start:\s*([\d.]+)/);
+        if (i) { de = Number(i[1]); continue; }
+        const f = linha.match(/freeze_end:\s*([\d.]+)/);
+        if (f && de != null) { juntar(de, Number(f[1])); de = null; }
+    }
+    if (de != null && duracao > de) juntar(de, duracao);
+    return trechos;
+}
+
+/** As medidas viram avisos. Puro. */
+function julgar({ som, parados = [] }, alvo = ALVO) {
+    const avisos = [];
+    if (som && Number.isFinite(som.lufs)) {
+        if (Math.abs(som.lufs - alvo.lufs) > alvo.folgaLufs) {
+            avisos.push(`volume em ${som.lufs} LUFS, longe do alvo de ${alvo.lufs} (${som.lufs < alvo.lufs ? 'baixo demais' : 'alto demais'})`);
+        }
+        if (som.pico != null && som.pico > alvo.picoMax) avisos.push(`pico de ${som.pico} dBTP: estoura no celular (o máximo é ${alvo.picoMax})`);
+    }
+    for (const p of parados) {
+        const dura = r1(p.ate - p.de);
+        if (dura >= alvo.paradoMin) avisos.push(`imagem parada por ${dura} s (de ${p.de} s a ${p.ate} s)`);
+    }
+    return avisos;
+}
+
+/** Mede o arquivo numa passada só do ffmpeg e devolve medidas e avisos. */
+async function conferir(arquivo, { duracao = 0 } = {}) {
+    const c = video.conferir();
+    if (!c.ok) return c;
+    const r = await video.rodar(video.ffmpeg(), [
+        '-hide_banner', '-nostats', '-i', arquivo,
+        '-vf', 'scale=320:-2,freezedetect=n=0.002:d=1.5',
+        '-af', 'ebur128=peak=true',
+        '-f', 'null', '-',
+    ], { timeout: 10 * 60000 });
+    if (!r.ok) return { ok: false, error: `a conferência não leu o vídeo: ${r.erro.slice(-200)}` };
+    const som = lerSom(r.erro);
+    const parados = lerParados(r.erro, duracao);
+    return { ok: true, som, parados, avisos: julgar({ som, parados }) };
+}
+
+module.exports = { ALVO, lerSom, lerParados, julgar, conferir };

package/lib/estudio/gerativo.js

@@ -486,8 +486,17 @@ const itensDe = (p) => [...(p.itens || []), ...(p.barras || []).map((b) => `${b.
     ...(p.cores || []).map((c) => (typeof c === 'string' ? c : `${c.nome || ''} ${c.hex || ''}`.trim()))]
     .map((i) => (typeof i === 'string' ? i : i.texto || i.titulo || '')).filter(Boolean);
 
+/* A parte que só traz `fala` (o modelo grátis escreve assim) não tinha nada
+   para a tela, e cada composição quebrava num lugar diferente (12/10). O
+   título vira a primeira oração da fala, com até 6 palavras. */
+function tituloDaFala(fala) {
+    const oracao = String(fala || '').split(/[.?!;:—]|,\s/).map((x) => x.trim()).find(Boolean) || '';
+    const w = oracao.split(/\s+/).filter(Boolean);
+    return w.length > 6 ? w.slice(0, 6).join(' ') + '…' : oracao + (/\?/.test(String(fala || '').slice(oracao.length, oracao.length + 2)) ? '?' : '');
+}
+
 function conteudoDe(p, marca = {}) {
-    const titulo = p.titulo || p.texto || '';
+    const titulo = p.titulo || p.texto || tituloDaFala(p.fala);
     const itens = itensDe(p);
     if (p.tipo === 'numero' && numeroDe(p.valor)) return { tipo: 'numero', valor: String(p.valor), rotulo: p.rotulo || titulo, sub: p.sub || '' };
     if (itens.length >= 2) return { tipo: 'lista', titulo: p.tipo === 'cores' ? titulo : titulo, itens: itens.slice(0, 5), numerada: p.tipo === 'passos' };
@@ -1072,6 +1081,14 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], icon
             });
             return;
         }
+        if (nome === 'duelo' && !(String(c.nao || '').trim() && String(c.sim || '').trim())) {
+            /* O "contraste" sem nao/sim (o roteiro só trouxe a fala, 12/10) virava
+               dois títulos vazios e o plano morria. Vira um título com o que a
+               voz diz no começo do trecho. */
+            const ditas = (ctx.palavras || []).filter((w) => w.de >= br.de - 0.05 && w.de < br.ate).slice(0, 5).map((w) => w.texto).join(' ');
+            registra(compor(anterior === 'gigante' ? 'pilha' : 'gigante', { ...br, conteudo: { tipo: 'titulo', titulo: c.titulo || c.texto || ditas || '…', sub: '', destaque: c.destaque || '' } }, ctx));
+            return;
+        }
         if (nome === 'duelo') {
             const meio = casar([c.sim], ctx.palavras, { de: br.de + 1.2 })[0];
             const corte = r3(Math.min(br.ate - 1.4, Math.max(br.de + 1.3, meio != null ? meio - 0.1 : (br.de + br.ate) / 2)));
@@ -1483,7 +1500,8 @@ function compor(comp, br, ctx) {
             comportamento: o.comportamento || null, riscado: !!o.riscado, envelhece: null,
         };
         l.palavras = l.texto.split(/\s+/).filter(Boolean).map((w) => ({ texto: w, papel: ehTese(w) ? 'tese' : funcao(w) ? 'funcao' : 'normal' }));
-        b.linhas.push(l);
+        // Linha sem palavra não entra na tela: todo o resto (acento, golpe, tempo) supõe ao menos uma (12/10).
+        if (l.palavras.length) b.linhas.push(l);
         return l;
     };
     // Os pesos DENTRO da frase: artigo leve, verbo regular, tese pesada e maior.
@@ -1520,6 +1538,10 @@ function compor(comp, br, ctx) {
                 if (!destaqueTk.length) l.palavras.forEach((p) => { p.papel = 'normal'; });
             }
             const ultima = b.linhas[b.linhas.length - 1];
+            /* Sem texto que caiba (a parte veio só com fala, sem título), a tela
+               fica sem linha — e o acento caía em undefined.palavras e matava o
+               plano inteiro (12/10, o estilo padrão quebrava). Sem linha, sem acento. */
+            if (!ultima) break;
             if (c.riscado) b.acento.push({ forma: 'risco', alvo: { linha: ultima.id } });
             else if (/[.!]$/.test(txt) || s.chance(0.4)) b.acento.push({ forma: 'ponto', alvo: { linha: ultima.id, fim: true } });
             else {
@@ -1859,7 +1881,7 @@ function contarAcentos(b) {
     return n;
 }
 
-module.exports = {
+module.exports = { tituloDaFala,
     montarGerativo, partituraDe, sonsDoVideo, musicaDe, desenharSom, humorDe, escolherVisual, MOLDURAS, AMBIENTES, ACENTOS_JEITO, ARRANJOS_ICONE, RITMOS_ICONE, MATERIAIS_ICONE, corGenerica, BANIDAS, HUMORES, REGRAS, VARIAVEIS, COMPOSICOES, COMPORTAMENTOS, SAIDAS, ACENTOS, FPS,
     especEixos, sorteador, hash, larguraEm, conteudoDe, casar, HEROIS_OBJETO, HEROIS_CAMPO, HEROIS_3D, FAMILIA_HEROI,
 };