primocode 8.27.0 → 8.31.0

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

package/lib/instalar-app.js

@@ -0,0 +1,231 @@
+/**
+ * instalar-app.js — o PrimoCode como aplicativo do sistema.
+ *
+ *   "Ele está abrindo no navegador, pode ser — só que eu gostaria que fosse um
+ *    aplicativo mesmo desktop, tenha um ícone, e o ícone tem que ser o mascote
+ *    do PrimoCode."
+ *
+ * ── O QUE ESTE ARQUIVO ENTREGA, E O QUE ELE NÃO ENTREGA ──────────────────
+ * Ele entrega o que faz uma coisa SER um aplicativo para quem usa: entrada no
+ * Launchpad e no Dock do Mac, no menu Iniciar e na barra de tarefas do Windows,
+ * no menu de aplicativos do Linux. Ícone próprio, nome próprio, abre com dois
+ * cliques, aparece no Spotlight e no Alt-Tab com a cara dele.
+ *
+ * O que ele NÃO faz é trocar o motor da janela. Dentro, continua sendo o
+ * Chromium da máquina em modo `--app`, sem barra de endereço e sem abas — é o
+ * mesmo desenho de sempre. Trocar isso por uma janela nativa exigiria Electron
+ * ou Tauri: um download de centenas de MB, uma cadeia de compilação por
+ * sistema e assinatura de código para o macOS e o Windows não recusarem o
+ * binário. Isso derruba a promessa de "já instala junto com o npm", que foi
+ * pedida na mesma frase.
+ *
+ * Está escrito aqui porque é a diferença que importa se um dia alguém quiser
+ * mudar: o obstáculo não é técnico, é o tamanho da instalação.
+ *
+ * ── POR QUE NÃO NO `postinstall` ─────────────────────────────────────────
+ * Um `npm i -g` que cria pasta em ~/Applications e escreve no menu Iniciar sem
+ * ninguém pedir é um instalador se comportando mal. Quem quiser o aplicativo
+ * digita `/app --instalar` uma vez, e o `/app` sozinho continua abrindo a
+ * janela sem instalar nada.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFile, execFileSync } = require('child_process');
+
+const icone = require('./icone.js');
+
+const NOME = 'PrimoCode';
+const CASA = path.join(os.homedir(), '.primocode');
+
+function escrever(destino, dados) {
+    fs.mkdirSync(path.dirname(destino), { recursive: true });
+    fs.writeFileSync(destino, dados);
+}
+
+/* O caminho do Node e o do CLI, absolutos.
+ *
+ * Aplicativo aberto pelo Finder ou pelo menu Iniciar NÃO herda o PATH do
+ * terminal: o `.zshrc` não roda, e num Mac com Node do Homebrew ou do nvm o
+ * comando `primo` simplesmente não existe para quem clicou no ícone. O
+ * aplicativo abria e fechava na hora, sem dizer nada. Com os dois caminhos
+ * escritos no lançador, ele funciona vindo de qualquer lugar. */
+function caminhos() {
+    return {
+        node: process.execPath,
+        cli: path.resolve(__dirname, '..', 'bin', 'primocode.js'),
+    };
+}
+
+// ── macOS ────────────────────────────────────────────────────────────────
+
+const PLIST = (versao) => `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleName</key><string>${NOME}</string>
+  <key>CFBundleDisplayName</key><string>${NOME}</string>
+  <key>CFBundleIdentifier</key><string>ai.conectaprimo.primocode</string>
+  <key>CFBundleVersion</key><string>${versao}</string>
+  <key>CFBundleShortVersionString</key><string>${versao}</string>
+  <key>CFBundlePackageType</key><string>APPL</string>
+  <key>CFBundleExecutable</key><string>${NOME}</string>
+  <key>CFBundleIconFile</key><string>${NOME}</string>
+  <key>NSHighResolutionCapable</key><true/>
+  <!-- Sem isto o ícone do Dock vira um foguete genérico e o app aparece com
+       o nome do processo. "LSUIElement" NÃO entra: com ele o aplicativo some
+       do Dock, e o Dock é metade do que foi pedido aqui.
+
+       (Aspas e não acento grave neste comentário de propósito: ele mora dentro
+       de um template literal, e um acento grave ali FECHA a string — o erro
+       sai vinte linhas abaixo, apontando para o lugar errado.) -->
+  <key>LSMinimumSystemVersion</key><string>10.15</string>
+</dict>
+</plist>
+`;
+
+function instalarMac(versao) {
+    const { node, cli } = caminhos();
+    const raiz = path.join(os.homedir(), 'Applications', `${NOME}.app`);
+    const conteudo = path.join(raiz, 'Contents');
+
+    escrever(path.join(conteudo, 'Info.plist'), PLIST(versao));
+    escrever(path.join(conteudo, 'Resources', `${NOME}.icns`), icone.icns());
+
+    /* O lançador. `exec` no fim para o processo do Node HERDAR o lugar do
+       script: sem ele o shell fica de pé só esperando, e o macOS mostra dois
+       processos no monitor de atividade para um aplicativo só. */
+    const bin = path.join(conteudo, 'MacOS', NOME);
+    escrever(bin, `#!/bin/sh
+# Gerado pelo PrimoCode (/app --instalar). Não edite: rode o comando de novo.
+exec ${JSON.stringify(node)} ${JSON.stringify(cli)} --app "$@"
+`);
+    fs.chmodSync(bin, 0o755);
+
+    /* O macOS guarda em cache o ícone e o nome pelo caminho do bundle. Sem
+       tocar na pasta, um app reinstalado continua mostrando o ícone velho até
+       o sistema reiniciar — o que parece, de fora, o comando não ter
+       funcionado. `touch` na pasta invalida esse cache. */
+    try { fs.utimesSync(raiz, new Date(), new Date()); } catch {}
+
+    return { ok: true, caminho: raiz, onde: 'Launchpad e pasta Aplicativos' };
+}
+
+// ── Windows ──────────────────────────────────────────────────────────────
+
+/* O atalho do Windows (.lnk) é um formato binário com estrutura própria. Em
+ * vez de montá-lo byte a byte, quem o escreve é o próprio Windows, pelo
+ * WScript.Shell — que existe em toda instalação desde sempre e é a API que os
+ * instaladores usam. */
+function instalarWindows(versao) {
+    const { node, cli } = caminhos();
+    const recursos = path.join(CASA, 'app');
+    const ico = path.join(recursos, 'primocode.ico');
+    escrever(ico, icone.ico());
+
+    /* Um .cmd abriria uma janela preta de console junto do aplicativo. O .vbs
+       com `Run ..., 0` lança o Node com a janela escondida — é o que faz o
+       aplicativo abrir só a janela dele, como qualquer programa. */
+    const vbs = path.join(recursos, 'primocode.vbs');
+    escrever(vbs, `' Gerado pelo PrimoCode (/app --instalar). Não edite: rode o comando de novo.\r
+Set sh = CreateObject("WScript.Shell")\r
+sh.Run """${node}"" ""${cli}"" --app", 0, False\r
+`);
+
+    const menu = path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'),
+        'Microsoft', 'Windows', 'Start Menu', 'Programs', `${NOME}.lnk`);
+    const area = path.join(os.homedir(), 'Desktop', `${NOME}.lnk`);
+
+    const ps = [
+        '$w = New-Object -ComObject WScript.Shell',
+        ...[menu, area].map((alvo) => [
+            `$s = $w.CreateShortcut(${JSON.stringify(alvo)})`,
+            '$s.TargetPath = "wscript.exe"',
+            `$s.Arguments = '"${vbs}"'`,
+            `$s.IconLocation = ${JSON.stringify(ico)}`,
+            `$s.Description = "PrimoCode ${versao}"`,
+            `$s.WorkingDirectory = ${JSON.stringify(path.dirname(cli))}`,
+            '$s.Save()',
+        ].join('; ')),
+    ].join('; ');
+
+    try {
+        fs.mkdirSync(path.dirname(menu), { recursive: true });
+        execFileSync('powershell', ['-NoProfile', '-NonInteractive', '-Command', ps],
+            { stdio: 'ignore', timeout: 30000 });
+    } catch (e) {
+        return { ok: false, error: `não consegui criar o atalho: ${e.message}` };
+    }
+    return { ok: true, caminho: menu, onde: 'menu Iniciar e Área de Trabalho' };
+}
+
+// ── Linux ────────────────────────────────────────────────────────────────
+
+function instalarLinux(versao) {
+    const { node, cli } = caminhos();
+    const icones = path.join(os.homedir(), '.local', 'share', 'icons', 'hicolor');
+    for (const t of [16, 32, 48, 64, 128, 256, 512]) {
+        escrever(path.join(icones, `${t}x${t}`, 'apps', 'primocode.png'), icone.png(t));
+    }
+    const arquivo = path.join(os.homedir(), '.local', 'share', 'applications', 'primocode.desktop');
+    escrever(arquivo, `[Desktop Entry]
+Type=Application
+Name=${NOME}
+Comment=Agente de engenharia em português
+Exec=${node} ${cli} --app
+Icon=primocode
+Terminal=false
+Categories=Development;Utility;
+StartupWMClass=primocode
+X-PrimoCode-Version=${versao}
+`);
+    fs.chmodSync(arquivo, 0o755);
+    // Sem atualizar o banco, o menu só mostra o aplicativo na sessão seguinte.
+    try {
+        execFileSync('update-desktop-database', [path.dirname(arquivo)],
+            { stdio: 'ignore', timeout: 15000 });
+    } catch { /* nem toda distribuição tem, e a entrada funciona sem */ }
+    return { ok: true, caminho: arquivo, onde: 'menu de aplicativos' };
+}
+
+// ── porta única ──────────────────────────────────────────────────────────
+
+function instalar(versao) {
+    try {
+        const p = os.platform();
+        if (p === 'darwin') return instalarMac(versao);
+        if (p === 'win32') return instalarWindows(versao);
+        return instalarLinux(versao);
+    } catch (e) {
+        return { ok: false, error: e.message };
+    }
+}
+
+/** Já instalado? Serve para o /app oferecer a instalação uma vez só. */
+function instalado() {
+    const p = os.platform();
+    const alvo = p === 'darwin'
+        ? path.join(os.homedir(), 'Applications', `${NOME}.app`)
+        : p === 'win32'
+            ? path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'),
+                'Microsoft', 'Windows', 'Start Menu', 'Programs', `${NOME}.lnk`)
+            : path.join(os.homedir(), '.local', 'share', 'applications', 'primocode.desktop');
+    try { return fs.existsSync(alvo) ? alvo : null; } catch { return null; }
+}
+
+function desinstalar() {
+    const alvo = instalado();
+    if (!alvo) return { ok: true, jaSaiu: true };
+    try {
+        fs.rmSync(alvo, { recursive: true, force: true });
+        if (os.platform() === 'win32') {
+            try { fs.rmSync(path.join(os.homedir(), 'Desktop', `${NOME}.lnk`), { force: true }); } catch {}
+        }
+        return { ok: true, caminho: alvo };
+    } catch (e) { return { ok: false, error: e.message }; }
+}
+
+module.exports = { instalar, instalado, desinstalar, NOME };