primocode 8.27.0 → 8.31.0

package/bin/primocode.js

@@ -26,6 +26,8 @@ const catalogo = require('../lib/catalogo');
 const effort = require('../lib/effort');
 const memoria = require('../lib/memoria-conversa');
 const appLib = require('../lib/app');
+const conta = require('../lib/conta');
+const nuvem = require('../lib/nuvem');
 
 // 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
@@ -55,6 +57,9 @@ const state = {
     // O resumo incremental da conversa — um /compact automático. O porquê
     // está em lib/memoria-conversa.js.
     memoria: memoria.nova(),
+    // O histórico que o app desktop e o celular enxergam. Cifrado antes de
+    // sair daqui; o porquê de cada peça está em lib/nuvem.js.
+    gravador: nuvem.gravador(),
     lastResponse: '',
     currentProject: null,
     workDir: null,     // pasta onde o agente trabalha nesta sessão
@@ -81,6 +86,9 @@ ${c.bold('Comandos')}
   ${c.brand('/run')} <comando>        executa no shell do projeto
   ${c.brand('/open')} <arquivo|url>   abre no navegador
   ${c.brand('/app')}                  abre a janela do PrimoCode (chat, sem terminal)
+  ${c.brand('/entrar')}               entra na sua conta Conecta Primo · ${c.brand('/conta')} mostra o plano
+  ${c.brand('/conversas')} [n]        suas conversas salvas — as mesmas do app e do celular
+  ${c.brand('/sair')}                 desconecta este computador
   ${c.brand('/status')}               checa o servidor
   ${c.brand('/name')} <nome>          como o Primo te chama
   ${c.brand('/mascot')} <estilo>      mascote: primo|fox|cat
@@ -122,6 +130,10 @@ const SLASH_COMANDOS = [
     ['/run', 'roda um comando'],
     ['/open', 'abre no navegador'],
     ['/app', 'abre a janela do PrimoCode'],
+    ['/entrar', 'entra na sua conta Conecta Primo'],
+    ['/conta', 'sua conta, plano e computadores conectados'],
+    ['/conversas', 'suas conversas salvas, as mesmas do app e do celular'],
+    ['/sair', 'desconecta este computador'],
     ['/status', 'checa o servidor'],
     ['/name', 'como ele te chama'],
     ['/mascot', 'primo | fox | cat'],
@@ -492,6 +504,10 @@ async function sendPrompt(userText) {
         state.history.push({ role: 'assistant', content: r.assistantMessage.content });
         state.lastResponse = r.assistantMessage.content;
         cfg.appendHistory({ mode: 'primocode', project: state.currentProject, prompt: userText });
+        // Sobe cifrado, atrás, sem segurar o prompt. Se não houver conta ou
+        // rede, não acontece nada — a conversa segue aqui do mesmo jeito.
+        state.gravador.turno(userText, r.assistantMessage.content,
+            { modo: 'primocode', projeto: state.currentProject || null });
     } else {
         await comprimirConversa();
         await runChat(prompt, userText);
@@ -634,6 +650,7 @@ async function runChat(promptForModel, userTextForMemory) {
         state.history.push({ role: 'assistant', content: text });
         state.lastResponse = text;
         cfg.appendHistory({ mode: 'chat', prompt: userTextForMemory });
+        state.gravador.turno(userTextForMemory, text, { modo: 'chat' });
     }
 }
 
@@ -903,7 +920,11 @@ async function handleSlash(text) {
             break;
         }
 
-        case 'clear': state.history = []; state.memoria = memoria.nova(); console.log(c.ok('Conversa limpa.')); break;
+        // Limpar aqui não apaga o que já subiu: encerra ESTA conversa e a
+        // próxima pergunta abre outra. Apagar do histórico é decisão da
+        // pessoa, e ela toma no app — não de raspão num comando de limpar tela.
+        case 'clear': state.history = []; state.memoria = memoria.nova();
+            state.gravador.zerar(); console.log(c.ok('Conversa limpa.')); break;
         case 'cls': process.stdout.write('\x1Bc'); break;
 
         case 'status': {
@@ -939,6 +960,21 @@ async function handleSlash(text) {
            Uma janela por sessão: mandar /app de novo traz a que já existe
            para a frente em vez de abrir outra do lado. */
         case 'app': {
+            // `/app --instalar` põe o PrimoCode no Dock, no menu Iniciar ou no
+            // menu de aplicativos, com o ícone do mascote. Uma vez só.
+            if (/^--?(instalar|install)$/.test(rest)) {
+                const r = require('../lib/instalar-app.js').instalar(VERSION);
+                console.log(r.ok
+                    ? c.ok('  Instalado.') + c.muted(`  Procure "PrimoCode" no ${r.onde}.`)
+                      + '\n' + c.dim(`  ${r.caminho}`)
+                    : c.err(`  Não deu: ${r.error}`));
+                break;
+            }
+            if (/^--?(desinstalar|uninstall)$/.test(rest)) {
+                const r = require('../lib/instalar-app.js').desinstalar();
+                console.log(r.ok ? c.ok('  Removido do sistema.') : c.err(`  ${r.error}`));
+                break;
+            }
             if (janelaAberta) {
                 // Já existe: reabre no MESMO endereço. O navegador traz a
                 // janela daquela URL para a frente em vez de fazer outra.
@@ -970,6 +1006,12 @@ async function handleSlash(text) {
                     console.log(c.warn('  Não consegui abrir sozinho — copie o endereço acima no navegador.'));
                 }
                 console.log(c.muted('  O terminal continua funcionando: os dois mostram a mesma coisa.'));
+                // Oferecido UMA vez, e só a quem ainda não tem: repetir todo
+                // /app viraria ruído para quem já instalou de propósito.
+                if (!require('../lib/instalar-app.js').instalado()) {
+                    console.log(c.dim('  Quer o ícone no ') + c.dim(os.platform() === 'darwin' ? 'Dock' : 'menu Iniciar')
+                        + c.dim('? ') + c.brand('/app --instalar'));
+                }
             } catch (e) {
                 sp.stop();
                 console.log(c.err(`  Não subiu: ${e.message}`));
@@ -977,6 +1019,135 @@ async function handleSlash(text) {
             break;
         }
 
+        /* A conta do Conecta Primo. O login inteiro mora em lib/conta.js;
+           aqui é a tela dele. */
+        case 'entrar': case 'login': {
+            const jaEsta = conta.atual();
+            if (jaEsta && rest !== 'trocar') {
+                console.log(c.muted('  Já conectado como ') + c.brand(jaEsta.uid.slice(0, 12) + '…')
+                    + c.muted(` · plano ${jaEsta.plano}`));
+                console.log(c.dim('  Para entrar com outra conta: ') + c.brand('/entrar trocar'));
+                break;
+            }
+            if (rest === 'trocar') conta.sair();
+
+            const sp = new Spinner('abrindo o login').start();
+            let primeiro = true;
+            const r = await conta.entrar({
+                abrir: (u) => tools.openInBrowser(u),
+                contar: (msg) => {
+                    if (primeiro) {
+                        sp.stop();
+                        console.log(c.muted('  Abrindo no navegador:'));
+                        console.log('  ' + c.brand(msg));
+                        primeiro = false;
+                    } else {
+                        // O código aparece AQUI para a pessoa comparar com o
+                        // da página. Sem essa comparação, um link mandado por
+                        // outra pessoa conectaria o computador dela à conta
+                        // de quem clicou.
+                        console.log(c.muted('  Confira o código na página: ') + c.bold(c.warn(msg)));
+                        console.log(c.dim('  Esperando você aprovar…'));
+                    }
+                },
+            });
+            sp.stop();
+            if (!r.ok) { console.log(c.err(`  ${r.error}`)); break; }
+            console.log(c.ok('  Conectado.')
+                + c.muted(`  Plano ${r.plano}${r.pro ? '' : ' — assine Premium no app para liberar tudo'}`));
+            break;
+        }
+
+        /* O histórico da conta — o MESMO que o app desktop e o celular
+           mostram. Sem número, lista; com número, abre e continua dali. */
+        case 'conversas': case 'historico': {
+            if (!conta.atual()) {
+                console.log(c.muted('  Não conectado. ') + c.brand('/entrar')
+                    + c.muted(' para ver suas conversas aqui, no app e no celular.'));
+                break;
+            }
+            const sp = new Spinner('lendo suas conversas').start();
+            const l = await nuvem.listarConversas({ limite: 20 });
+            sp.stop();
+            if (!l.ok) { console.log(c.err(`  ${l.error}`)); break; }
+            if (!l.conversas.length) {
+                console.log(c.muted('  Nenhuma conversa salva ainda. A próxima já fica.'));
+                break;
+            }
+            if (!rest) {
+                console.log(c.white('\n  Suas conversas'));
+                l.conversas.forEach((x, i) => {
+                    const quando = x.atualizada
+                        ? new Date(x.atualizada).toLocaleDateString('pt-BR') : '—';
+                    console.log('  ' + c.dim(String(i + 1).padStart(2))
+                        + ' ' + c.white(x.titulo.slice(0, 52).padEnd(52))
+                        + c.dim(`${String(x.mensagens).padStart(3)} msg  ${quando}`));
+                });
+                console.log(c.dim('\n  /conversas 1  abre a primeira e continua dela.'));
+                break;
+            }
+            const n = Number(rest);
+            const alvo = l.conversas[n - 1];
+            if (!alvo) { console.log(c.err(`  Não achei a conversa ${rest}.`)); break; }
+            const sp2 = new Spinner('abrindo').start();
+            const conv = await nuvem.lerConversa(alvo.id);
+            sp2.stop();
+            if (!conv.ok) { console.log(c.err(`  ${conv.error}`)); break; }
+            // A memória entra ZERADA: o resumo antigo não veio junto, e um
+            // resumo de outra conversa colado aqui faria o modelo responder
+            // sobre coisa que não foi dita nesta.
+            state.history = conv.mensagens.map((m) => ({
+                role: m.papel, content: m.texto,
+            }));
+            state.memoria = memoria.nova();
+            state.gravador.retomar(alvo.id, alvo.titulo, conv.mensagens.length);
+            console.log(c.ok(`  ${alvo.titulo}`)
+                + c.muted(`  · ${conv.mensagens.length} mensagens carregadas`));
+            console.log(c.dim('  Pode continuar daqui — o que você disser volta pro app e pro celular.'));
+            break;
+        }
+
+        case 'sair': case 'logout': {
+            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 /entrar.'));
+            break;
+        }
+
+        case 'conta': {
+            const eu = conta.atual();
+            if (!eu) {
+                console.log(c.muted('  Não conectado. ') + c.brand('/entrar') + c.muted(' para entrar.'));
+                break;
+            }
+            const sp = new Spinner('conferindo').start();
+            // O plano guardado é a foto do dia do login: quem assinou ontem
+            // continuaria gratuito. Quem sabe é o servidor.
+            const s = await conta.sessao();
+            sp.stop();
+            console.log(c.white('  Conta   ') + c.muted(eu.uid));
+            if (s.ok) {
+                console.log(c.white('  Plano   ')
+                    + (s.pro ? c.brand(s.plano) : c.muted(s.plano + ' (gratuito)')));
+            } else if (s.offline) {
+                console.log(c.white('  Plano   ') + c.muted(eu.plano) + c.dim('  (sem rede — último conhecido)'));
+            } else {
+                console.log(c.err(`  ${s.error}`));
+                break;
+            }
+            const d = await conta.dispositivos();
+            if (d.ok && d.dispositivos.length) {
+                console.log(c.white('\n  Computadores conectados'));
+                for (const x of d.dispositivos) {
+                    const quando = x.ultimo_uso
+                        ? new Date(x.ultimo_uso * 1000).toLocaleDateString('pt-BR') : '—';
+                    console.log('    ' + c.muted((x.apelido || 'Computador').padEnd(14)) + c.dim(quando));
+                }
+            }
+            break;
+        }
+
         case 'uninstall': {
             if (await confirm('Remover o PrimoCode? Seus projetos em ~/primocode NÃO serão apagados.')) {
                 await tools.uninstall();
@@ -1049,6 +1220,53 @@ async function main() {
         process.exit(0);
     }
 
+    /* `primo --app`: a janela SEM terminal.
+     *
+     * É por aqui que o aplicativo instalado entra. Quem clica no ícone do Dock
+     * ou do menu Iniciar não tem terminal nenhum — não há readline, não há
+     * stdin, e o processo precisa ficar de pé sozinho segurando a janela.
+     *
+     * O `/app` de dentro da sessão continua existindo e é outra coisa: ali há
+     * um terminal, e a janela espelha o que ele mostra. Os dois chamam a MESMA
+     * `appLib.abrir`, porque uma segunda montagem divergiria da primeira. */
+    if (args[0] === '--app') {
+        const instalador = require('../lib/instalar-app.js');
+        if (args[1] === '--instalar') {
+            const r = instalador.instalar(VERSION);
+            console.log(r.ok
+                ? c.ok(`  Instalado.`) + c.muted(`  Procure "PrimoCode" no ${r.onde}.`)
+                  + '\n' + c.dim(`  ${r.caminho}`)
+                : c.err(`  Não deu: ${r.error}`));
+            process.exit(r.ok ? 0 : 1);
+        }
+        if (args[1] === '--desinstalar') {
+            const r = instalador.desinstalar();
+            console.log(r.ok ? c.ok('  Removido do sistema.') : c.err(`  ${r.error}`));
+            process.exit(r.ok ? 0 : 1);
+        }
+
+        const janela = await appLib.abrir({
+            versao: VERSION,
+            enviar: (t) => sendPrompt(t),
+            barra: (t) => handleSlash(t),
+            interromper,
+            estado: () => ({
+                pasta: state.workDir ? shortPath(state.workDir) : null,
+                projeto: state.currentProject,
+                modo: state.mode,
+                esforco: state.config.effort,
+            }),
+        });
+        janelaAberta = janela;
+        console.log(c.brand(`  PrimoCode`) + c.muted(`  ${janela.url.split('?')[0]}`));
+        // Sem readline não há nada segurando o laço de eventos além do
+        // servidor — e é ele que segura, porque está escutando. Fechar a
+        // janela NÃO derruba o processo de propósito: o navegador em modo app
+        // reabre a mesma URL, e um servidor morto deixaria a pessoa com uma
+        // aba de erro em vez do aplicativo.
+        return;
+    }
+
     // Modo one-shot: primocode "crie um jogo de carro"
     if (args.length && !args[0].startsWith('-')) {
         const fileFlag = args.indexOf('-f');
@@ -1150,7 +1368,19 @@ async function main() {
     function sayBye() {
         if (saidBye) return;
         saidBye = true;
-        console.log(c.muted('\nAté logo!'));
+        // O último turno pode ainda estar subindo — gravar é de propósito
+        // solto, para não segurar o prompt. Fechar o terminal em cima dele
+        // perderia justamente a resposta que a pessoa acabou de ler, e ela
+        // não veria falta nenhuma até procurar no celular.
+        const fim = () => console.log(c.muted('\nAté logo!'));
+        Promise.race([
+            state.gravador.esperar(),
+            // Rede pendurada não vira terminal pendurado. `unref` porque o
+            // temporizador sozinho seguraria o processo por 3s mesmo quando a
+            // gravação já terminou — um "Até logo!" seguido de três segundos
+            // de nada é o tipo de coisa que quem usa chama de travado.
+            new Promise((r) => { const t = setTimeout(r, 3000); if (t.unref) t.unref(); }),
+        ]).then(fim, fim);
     }
 
     async function drain() {

package/lib/catalogo.js

@@ -89,6 +89,10 @@ const GRUPOS = [
             { tool: 'studio_listar',    escreve: false, faz: 'lista o que já existe no estúdio', args: null },
             { tool: 'studio_midia',     escreve: false, faz: 'manda imagem, música ou vídeo seu para usar nas peças',
               args: 'arquivo (opcional): caminho no projeto — sem ele, lista a galeria. nome (opcional).' },
+            { tool: 'remotion_projeto', escreve: true, faz: 'transforma uma peça do estúdio em projeto Remotion (React) na pasta do usuário',
+              args: 'id da peça. pasta (opcional): nome da pasta. fps (opcional, padrão 30). renderizar: true só se o npm install já foi feito. '
+                + 'Use SÓ quando o usuário pedir Remotion pelo nome, ou quando precisar de render determinístico, vídeo longo, codec/fps específico ou o projeto em React. '
+                + 'O caminho normal continua sendo studio_criar + o botão de baixar, que sai em segundos sem instalar nada.' },
             { tool: 'studio_analisar',  escreve: false, faz: 'ouve um vídeo já enviado e diz onde estão as pausas, para cortá-las',
               args: 'arquivo: a URL "/midia/..." do vídeo. pausa (opcional): segundos a partir dos quais conta como pausa (padrão 0.6). Devolve "trechos": vire cada um numa cena com {"tipo":"clipe","de":...,"ate":...}.' },
         ],

package/lib/conta.js

@@ -0,0 +1,197 @@
+/**
+ * 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."
+ *
+ * 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.
+ *
+ * ── 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á).
+ */
+
+'use strict';
+
+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 ARQUIVO = path.join(os.homedir(), '.primocode', 'conta.json');
+
+// 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) {
+    return new Promise((resolve, reject) => {
+        const url = new URL(CONECTA + 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;
+        }
+        const cred = 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();
+    });
+}
+
+// ── o arquivo ────────────────────────────────────────────────────────────
+
+function ler() {
+    try { return JSON.parse(fs.readFileSync(ARQUIVO, 'utf8')); }
+    catch { return null; }
+}
+
+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.
+    try { fs.chmodSync(ARQUIVO, 0o600); } catch {}
+}
+
+function sair() {
+    try { fs.rmSync(ARQUIVO, { force: true }); return true; }
+    catch { return false; }
+}
+
+/** Quem está conectado, sem ir à rede. */
+function atual() {
+    const c = ler();
+    if (!c || !c.token) return null;
+    return { uid: c.uid, plano: c.plano || 'free', email: c.email || null,
+        pro: PLANOS_PRO.includes(c.plano), desde: c.desde };
+}
+
+// ── entrar ───────────────────────────────────────────────────────────────
+
+/**
+ * O login inteiro: pede o código, abre o navegador, espera a aprovação.
+ *
+ * @param {object} op
+ * @param {(url:string)=>any} op.abrir     abre o navegador (vem do tools.js)
+ * @param {(msg:string)=>void} [op.contar] para a tela ir dizendo o que faz
+ * @param {number} [op.minutos]            teto da espera
+ */
+async function entrar({ abrir, contar = () => {}, minutos = 5 } = {}) {
+    let pedido;
+    try {
+        pedido = await pedir('/api/dispositivo/novo', { origem: `PrimoCode ${versao()}` });
+    } 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' };
+    }
+
+    contar(pedido.url);
+    contar(pedido.codigo);
+    if (abrir) { try { await abrir(pedido.url); } catch { /* segue: o link está na tela */ } }
+
+    /* 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,
+        });
+        return { ok: true, uid: r.uid, plano: r.plano,
+            pro: PLANOS_PRO.includes(r.plano) };
+    }
+    return { ok: false, error: `passaram ${minutos} minutos sem aprovação. Rode /entrar de novo.` };
+}
+
+/**
+ * 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ó.
+ */
+async function sessao() {
+    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' };
+    }
+    // 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 };
+}
+
+/** 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 versao() {
+    try { return require('../package.json').version; } catch { return '?'; }
+}
+
+module.exports = { entrar, sair, atual, sessao, dispositivos, ARQUIVO, CONECTA, PLANOS_PRO };