primocode 8.27.0 → 8.30.0

package/bin/primocode.js

@@ -26,6 +26,7 @@ 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');
 
 // 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
@@ -81,6 +82,8 @@ ${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('/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 +125,9 @@ 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'],
+    ['/sair', 'desconecta este computador'],
     ['/status', 'checa o servidor'],
     ['/name', 'como ele te chama'],
     ['/mascot', 'primo | fox | cat'],
@@ -939,6 +945,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 +991,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 +1004,86 @@ 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;
+        }
+
+        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 +1156,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');

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

package/lib/icone.js

@@ -0,0 +1,247 @@
+/**
+ * icone.js — o mascote do PrimoCode, desenhado em pixel e empacotado.
+ *
+ *   "Tenha um ícone, e o ícone tem que ser o mascote do PrimoCode, tem que ter
+ *    todas as cores do PrimoCode."
+ *
+ * ── POR QUE DESENHAR EM VEZ DE GUARDAR UM ARQUIVO ────────────────────────
+ * Um .icns e um .ico são formatos binários com várias resoluções dentro. Podia
+ * ter os dois no repositório, prontos — só que cada um seria uma cópia do
+ * desenho, e mudar a cor da marca passaria a exigir abrir um editor de imagem e
+ * lembrar dos dois. O mascote é blocado por natureza (ele nasceu de glifos de
+ * bloco no terminal), então desenhá-lo em código é curto e a fonte é UMA.
+ *
+ * ── POR QUE SEM BIBLIOTECA ───────────────────────────────────────────────
+ * O PrimoCode tem zero dependência, e isso não abre exceção para um ícone.
+ * PNG é um cabeçalho, os pixels passados pelo `zlib` (que vem no Node) e um
+ * CRC-32; .icns e .ico são containers que só empacotam PNGs prontos. São umas
+ * cem linhas somando os três, contra um pacote de imagem inteiro na árvore.
+ */
+
+'use strict';
+
+const zlib = require('zlib');
+
+// As cores são as MESMAS do lib/ui.js e do app/app.css — a marca é uma só.
+const AZUL = [0x22, 0xd3, 0xee];   // cyan-400 — o azul do PrimoCode
+const AZUL_FUNDO = [0x08, 0x91, 0xb2];   // cyan-600 — a mesma cor recuando
+const FUNDO = [0x0a, 0x0f, 0x16];   // o quase-preto do app
+const BRILHO = [0x67, 0xe8, 0xf9];   // cyan-300 — a luz de cima
+
+// ── tela de pixels ───────────────────────────────────────────────────────
+
+function tela(n) {
+    // RGBA, quatro bytes por pixel, começando transparente.
+    return { n, px: Buffer.alloc(n * n * 4) };
+}
+
+function ponto(t, x, y, cor, alfa) {
+    x = Math.round(x); y = Math.round(y);
+    if (x < 0 || y < 0 || x >= t.n || y >= t.n) return;
+    const i = (y * t.n + x) * 4;
+    const a = alfa == null ? 1 : alfa;
+    if (a >= 1) {
+        t.px[i] = cor[0]; t.px[i + 1] = cor[1]; t.px[i + 2] = cor[2]; t.px[i + 3] = 255;
+        return;
+    }
+    // Mistura sobre o que já está lá — é o que dá a borda macia do arredondado.
+    const de = t.px[i + 3] / 255;
+    const fora = a + de * (1 - a);
+    for (let k = 0; k < 3; k++) {
+        t.px[i + k] = Math.round((cor[k] * a + t.px[i + k] * de * (1 - a)) / (fora || 1));
+    }
+    t.px[i + 3] = Math.round(fora * 255);
+}
+
+/* Retângulo de cantos redondos, com a borda suavizada por amostragem.
+ *
+ * Sem a suavização o ícone fica com escada visível em 512px e, pior, some o
+ * arredondado em 16px — que é o tamanho em que ele mais aparece (aba, barra de
+ * tarefas, Dock recolhido). Três por três amostras bastam: nove níveis de
+ * cobertura é mais do que o olho separa numa borda de um pixel. */
+function caixa(t, x0, y0, l, a, r, cor) {
+    const x1 = x0 + l, y1 = y0 + a;
+    for (let y = Math.floor(y0) - 1; y <= Math.ceil(y1) + 1; y++) {
+        for (let x = Math.floor(x0) - 1; x <= Math.ceil(x1) + 1; x++) {
+            let dentro = 0;
+            for (let sy = 0; sy < 3; sy++) {
+                for (let sx = 0; sx < 3; sx++) {
+                    const px = x + (sx + 0.5) / 3;
+                    const py = y + (sy + 0.5) / 3;
+                    if (px < x0 || px > x1 || py < y0 || py > y1) continue;
+                    // Só os quatro cantos têm curva; o miolo é reto.
+                    const cx = px < x0 + r ? x0 + r : (px > x1 - r ? x1 - r : px);
+                    const cy = py < y0 + r ? y0 + r : (py > y1 - r ? y1 - r : py);
+                    if ((px - cx) ** 2 + (py - cy) ** 2 <= r * r) dentro++;
+                }
+            }
+            if (dentro) ponto(t, x, y, cor, dentro / 9);
+        }
+    }
+}
+
+// ── o mascote ────────────────────────────────────────────────────────────
+
+/* O Primo, o mesmo do terminal: cabeça de topo arredondado, ombros largos,
+ * dois pezinhos. Lá ele é feito de glifos de bloco:
+ *
+ *      ▐▛███▜▌        a cabeça
+ *     ▝▜█████▛▘       o corpo, mais largo
+ *       ▘▘ ▝▝         os pés
+ *
+ * Aqui são as mesmas três peças em proporção, e não uma transliteração dos
+ * glifos: meio bloco de terminal vira escada num ícone de 512px. O que faz
+ * reconhecer é a SILHUETA — topo redondo, ombro saliente, dois pés —, e ela é
+ * a mesma.
+ */
+function desenharPrimo(n) {
+    const t = tela(n);
+    const u = n / 32;                      // a grade do desenho, em pixels
+
+    // A base: o quadrado escuro do app, com o mesmo arredondado do ícone de
+    // sistema (22% do lado é o raio que o macOS e o Windows usam hoje).
+    caixa(t, 0, 0, n, n, n * 0.22, FUNDO);
+
+    // Um brilho fraco atrás do bicho — o mesmo halo do fundo do app.
+    for (let y = 0; y < n; y++) {
+        for (let x = 0; x < n; x++) {
+            const dx = (x - n / 2) / (n * 0.6);
+            const dy = (y - n * 0.34) / (n * 0.6);
+            const d = Math.sqrt(dx * dx + dy * dy);
+            if (d < 1) ponto(t, x, y, AZUL, 0.11 * (1 - d) * (1 - d));
+        }
+    }
+
+    // Cabeça: topo arredondado, ombros retos embaixo (raio só em cima é o que
+    // dá a silhueta do ▐▛███▜▌ — redondo por cima, quadrado por baixo).
+    caixa(t, 9 * u, 7 * u, 14 * u, 11 * u, 3.4 * u, AZUL);
+    caixa(t, 9 * u, 14 * u, 14 * u, 4 * u, 0.6 * u, AZUL);
+
+    // Corpo: mais largo que a cabeça, que é o ombro marcado do desenho.
+    caixa(t, 6 * u, 17.6 * u, 20 * u, 7.6 * u, 2.2 * u, AZUL);
+
+    // Os dois pés.
+    caixa(t, 10 * u, 24.6 * u, 4.4 * u, 2.6 * u, 1 * u, AZUL_FUNDO);
+    caixa(t, 17.6 * u, 24.6 * u, 4.4 * u, 2.6 * u, 1 * u, AZUL_FUNDO);
+
+    // Os olhos, no negativo — é o que faz o bloco virar bicho.
+    caixa(t, 12.4 * u, 10.6 * u, 2.6 * u, 3.2 * u, 1.1 * u, FUNDO);
+    caixa(t, 17 * u, 10.6 * u, 2.6 * u, 3.2 * u, 1.1 * u, FUNDO);
+
+    // A luz de cima: uma faixa clara na testa e no ombro. Sem ela o bicho é
+    // uma silhueta chapada — é o mesmo bisel do "vidro" do estúdio.
+    caixa(t, 10.4 * u, 8.2 * u, 11.2 * u, 1.4 * u, 0.7 * u, BRILHO);
+    caixa(t, 7.6 * u, 18.6 * u, 16.8 * u, 1.2 * u, 0.6 * u, BRILHO);
+
+    return t;
+}
+
+// ── PNG ──────────────────────────────────────────────────────────────────
+
+const TABELA_CRC = (() => {
+    const t = new Int32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        t[n] = c;
+    }
+    return t;
+})();
+
+function crc32(buf) {
+    let c = -1;
+    for (let i = 0; i < buf.length; i++) c = TABELA_CRC[(c ^ buf[i]) & 0xff] ^ (c >>> 8);
+    return (c ^ -1) >>> 0;
+}
+
+function pedaco(tipo, dados) {
+    const cabeca = Buffer.alloc(8);
+    cabeca.writeUInt32BE(dados.length, 0);
+    cabeca.write(tipo, 4, 'latin1');
+    const crc = Buffer.alloc(4);
+    crc.writeUInt32BE(crc32(Buffer.concat([Buffer.from(tipo, 'latin1'), dados])), 0);
+    return Buffer.concat([cabeca, dados, crc]);
+}
+
+function paraPng(t) {
+    const linha = t.n * 4;
+    // Cada linha do PNG começa com o byte do filtro. Zero — "sem filtro" — é o
+    // certo aqui: o desenho é de blocos chapados, o zlib já o comprime bem, e
+    // filtro melhoraria bytes num arquivo que já sai com poucos KB.
+    const cru = Buffer.alloc((linha + 1) * t.n);
+    for (let y = 0; y < t.n; y++) {
+        cru[y * (linha + 1)] = 0;
+        t.px.copy(cru, y * (linha + 1) + 1, y * linha, (y + 1) * linha);
+    }
+    const ihdr = Buffer.alloc(13);
+    ihdr.writeUInt32BE(t.n, 0);
+    ihdr.writeUInt32BE(t.n, 4);
+    ihdr[8] = 8;      // 8 bits por canal
+    ihdr[9] = 6;      // cor 6 = RGBA
+    return Buffer.concat([
+        Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+        pedaco('IHDR', ihdr),
+        pedaco('IDAT', zlib.deflateSync(cru, { level: 9 })),
+        pedaco('IEND', Buffer.alloc(0)),
+    ]);
+}
+
+/** O mascote em PNG, no tamanho pedido. */
+function png(tamanho) {
+    return paraPng(desenharPrimo(tamanho));
+}
+
+// ── .icns (macOS) e .ico (Windows) ───────────────────────────────────────
+
+/* Os dois são containers de PNGs, e é por isso que cabem em vinte linhas cada.
+ * Os tamanhos não são gosto: são os que cada sistema procura. Faltando um, ele
+ * escala o vizinho e o ícone sai borrado justamente na barra de tarefas. */
+const TIPOS_ICNS = [
+    ['icp4', 16], ['icp5', 32], ['icp6', 64],
+    ['ic07', 128], ['ic08', 256], ['ic09', 512], ['ic10', 1024],
+];
+
+function icns() {
+    const partes = [];
+    for (const [tipo, tam] of TIPOS_ICNS) {
+        const dados = png(tam);
+        const cab = Buffer.alloc(8);
+        cab.write(tipo, 0, 'latin1');
+        cab.writeUInt32BE(dados.length + 8, 4);
+        partes.push(cab, dados);
+    }
+    const corpo = Buffer.concat(partes);
+    const cabeca = Buffer.alloc(8);
+    cabeca.write('icns', 0, 'latin1');
+    cabeca.writeUInt32BE(corpo.length + 8, 4);
+    return Buffer.concat([cabeca, corpo]);
+}
+
+const TAMANHOS_ICO = [16, 32, 48, 64, 128, 256];
+
+function ico() {
+    const imagens = TAMANHOS_ICO.map((t) => ({ t, dados: png(t) }));
+    const cabeca = Buffer.alloc(6);
+    cabeca.writeUInt16LE(0, 0);
+    cabeca.writeUInt16LE(1, 2);                    // 1 = ícone
+    cabeca.writeUInt16LE(imagens.length, 4);
+
+    let deslocamento = 6 + imagens.length * 16;
+    const entradas = [];
+    for (const im of imagens) {
+        const e = Buffer.alloc(16);
+        // 256 se escreve como 0 no .ico — o campo tem um byte só.
+        e[0] = im.t >= 256 ? 0 : im.t;
+        e[1] = im.t >= 256 ? 0 : im.t;
+        e[2] = 0;                                   // paleta: nenhuma
+        e.writeUInt16LE(1, 4);                      // planos
+        e.writeUInt16LE(32, 6);                     // bits por pixel
+        e.writeUInt32LE(im.dados.length, 8);
+        e.writeUInt32LE(deslocamento, 12);
+        deslocamento += im.dados.length;
+        entradas.push(e);
+    }
+    return Buffer.concat([cabeca, ...entradas, ...imagens.map((i) => i.dados)]);
+}
+
+module.exports = { png, icns, ico, AZUL, FUNDO, TAMANHOS_ICO, TIPOS_ICNS };