primocode 10.6.0 → 10.7.1

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/cenarios.js

@@ -0,0 +1,91 @@
+/**
+ * cenarios.js — os cenários que a IA criou e a pessoa deixou guardar.
+ *
+ *   "a IA vai criar os próprios cenários, além de ter os próprios cenários
+ *    prontos, e pede pro usuário se pode salvar pra usar na próxima vez."
+ *    (Joel, 12/10)
+ *
+ * Os lugares prontos moram no mundo.js (praia, cidade, cobertura…). A IA já
+ * podia mudar o céu, o chão, a luz e os elementos de UMA cena; o que se perdia
+ * era o resultado: o próximo vídeo começava do zero. Aqui o cenário inventado
+ * ganha nome e fica em ~/.primocode/cenarios.json — só com o "sim" da pessoa
+ * (a ferramenta recusa sem `autorizado: true`) — e vira um lugar como os
+ * outros: `lugar: "<nome>"` na cena o traz de volta.
+ *
+ * Só se guarda o que o mundo.js sabe desenhar: o lugar base, cores #rrggbb,
+ * a hora e até 7 elementos. Nada de caminho de arquivo nem código.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const arquivo = () => path.join(os.homedir(), '.primocode', 'cenarios.json');
+const ehCor = (c) => typeof c === 'string' && /^#[0-9a-f]{6}$/i.test(c);
+const TIPOS_DE_CHAO = ['areia', 'asfalto', 'grama', 'neve', 'lua', 'madeira', 'ladrilho'];
+const HORAS = ['noite', 'por_do_sol', 'amanhecer'];
+
+/** "Loja da Ana à noite" → "loja_da_ana_a_noite" (o mesmo jeito dos lugares do mundo.js). */
+function chave(nome) {
+    return String(nome || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_').replace(/^_|_$/g, '').slice(0, 40);
+}
+
+function lerTudo() {
+    try { const j = JSON.parse(fs.readFileSync(arquivo(), 'utf8')); return j && typeof j === 'object' ? j : {}; } catch { return {}; }
+}
+
+/** Só o que o mundo sabe desenhar; o resto cai fora em silêncio. */
+function limpar(c, bases) {
+    const o = c && typeof c === 'object' ? c : {};
+    const base = chave(o.base || o.lugar);
+    const out = { base: bases.includes(base) ? base : 'cobertura' };
+    if (typeof o.descricao === 'string') out.descricao = o.descricao.slice(0, 200);
+    if (Array.isArray(o.ceu) && o.ceu.length === 2 && o.ceu.every(ehCor)) out.ceu = o.ceu;
+    for (const k of ['parede', 'luz', 'acento']) if (ehCor(o[k])) out[k] = o[k];
+    if (o.chao && typeof o.chao === 'object') {
+        const ch = {};
+        if (TIPOS_DE_CHAO.includes(o.chao.tipo)) ch.tipo = o.chao.tipo;
+        if (ehCor(o.chao.cor)) ch.cor = o.chao.cor;
+        if (ehCor(o.chao.cor2)) ch.cor2 = o.chao.cor2;
+        if (Object.keys(ch).length) out.chao = ch;
+    } else if (ehCor(o.chao)) out.chao = { cor: o.chao, cor2: o.chao };
+    if (HORAS.includes(o.hora)) out.hora = o.hora.replace(/_/g, ' ');
+    if (Array.isArray(o.elementos)) {
+        const els = o.elementos.map((e) => (typeof e === 'string' ? e : e && e.nome) || '').map((s) => String(s).slice(0, 40)).filter(Boolean).slice(0, 7);
+        if (els.length) out.elementos = els;
+    }
+    return out;
+}
+
+/**
+ * Guarda o cenário. `autorizado` é a resposta da pessoa: sem ela, nada é escrito.
+ * @param {{nome:string, cenario:object, autorizado:boolean, bases:string[]}} op
+ */
+function salvar({ nome, cenario, autorizado, bases = [] } = {}) {
+    if (autorizado !== true) {
+        return { ok: false, error: 'falta o sim da pessoa.', comoResolver: 'pergunte "posso salvar este cenário pra usar na próxima vez?" e só chame de novo com autorizado:true se ela disser que sim.' };
+    }
+    const k = chave(nome);
+    if (!k) return { ok: false, error: 'dê um nome ao cenário (ex: "loja da Ana à noite").' };
+    if (bases.includes(k)) return { ok: false, error: `"${k}" já é um lugar pronto; escolha outro nome.` };
+    const tudo = lerTudo();
+    const novo = { ...limpar(cenario, bases), nome: String(nome).slice(0, 60), salvo: new Date().toISOString() };
+    tudo[k] = novo;
+    fs.mkdirSync(path.dirname(arquivo()), { recursive: true });
+    fs.writeFileSync(arquivo(), JSON.stringify(tudo, null, 2));
+    return { ok: true, chave: k, cenario: novo, comoUsar: `na próxima cena, lugar:"${k}" traz este cenário de volta.` };
+}
+
+function ler(nome) {
+    const k = chave(nome);
+    return k ? lerTudo()[k] || null : null;
+}
+
+function listar() {
+    return Object.entries(lerTudo()).map(([k, c]) => ({ chave: k, nome: c.nome, base: c.base, descricao: c.descricao || '' }));
+}
+
+module.exports = { salvar, ler, listar, limpar, chave, arquivo };

package/lib/estudio/colecao.js

@@ -198,6 +198,7 @@ function cardapio() {
         personagens3d: 'o estilo personagem (voxel): bonecos de blocos e o mascote, com a câmera de cinema — estudio_roteiro estilo:"personagem"',
         efeitosSonoros: { sintetizados: sons, internet: 'acao:efeito termo:"whoosh" (Openverse, licença aberta, até 6 s)' },
         musicas: { internet: 'acao:trilha termo:"lofi" (Openverse, 30 s ou mais)', automatica: 'sem trilha pedida, o PrimoCode escolhe uma sem repetir as últimas' },
+        movimentos: { quantos: Object.keys(require('./movimentos.js').CATALOGO).length, acao: 'movimentos', exemplo: 'termo:"quique" → movimento:"quicar-de-baixo"' },
         fontes: { quantas: fontes || 128, acao: 'fontes', nota: 'Google Fonts, por tipo (condensada, display, serifada, manuscrita…)' },
         imagens: 'acao:imagem termo:"…" (Openverse e Wikimedia; Google com chave) — só quando a pessoa pediu imagem',
     };

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,
 };