@neetru/cli 2.29.0 → 2.32.0

package/dist/lib/public-secret-scan.js

@@ -0,0 +1,771 @@
+/**
+ * Varredura de segredo no pacote PÚBLICO antes do `neetru deploy` (2.30.0).
+ *
+ * Decisão do dono (2026-10-03): a credencial `nrt_` do produto é SÓ DE
+ * SERVIDOR. Hoje produtos carregam a chave no bundle do navegador
+ * (`NEXT_PUBLIC_NEETRU_API_KEY`, `NEXT_PUBLIC_NEETRU_PUBLIC_KEY`) — qualquer
+ * visitante abre o DevTools e copia. Este gate impede que um segredo saia no
+ * artefato servido ao público.
+ *
+ * O que é "público" (servido ao navegador): `.next/static/**`, `public/**`,
+ * `out/**`, `dist/**`, `build/**` — e, na stack `static`, o pacote inteiro.
+ * `node_modules/**` nunca entra (código de terceiros, não servido como asset).
+ *
+ * O que procuramos:
+ *   1. `nrt_[A-Za-z0-9_-]{20,}` — credencial de API do produto (Neetru).
+ *   2. `npk_[A-Za-z0-9_-]{20,}` — chave de produto Neetru.
+ *   3. `-----BEGIN … PRIVATE KEY-----` + material base64 — chave privada PEM
+ *      (RSA/EC/OPENSSH/PKCS8). Só o cabeçalho (código de lib) não conta.
+ *   4. VALOR literal de env pública (`NEXT_PUBLIC_*`, `EXPO_PUBLIC_*`,
+ *      `VITE_*`, `REACT_APP_*`, `PUBLIC_*`) cujo NOME contém KEY/SECRET/TOKEN —
+ *      é exatamente o que o bundler injeta no JS do navegador.
+ *      Exceção por FORMATO de valor sabidamente público: Stripe publishable
+ *      (`pk_live_`/`pk_test_`), chave web Google/Firebase (`AIza…`), reCAPTCHA
+ *      site key (`6L…`). Nome não isenta nada (`NEXT_PUBLIC_NEETRU_PUBLIC_KEY`
+ *      é justamente a chave `nrt_` no navegador).
+ *
+ * Saída: NUNCA imprime o segredo. Mostra no máximo os 8 primeiros caracteres
+ * (e nunca mais que 1/4 do valor), seguidos de máscara.
+ *
+ * Sem dependências: o .tar.gz é lido em streaming (zlib + parser ustar/GNU/pax).
+ */
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import zlib from 'node:zlib';
+import { problemaDeCodificacao, semBomInicial } from './texto-utf8.js';
+import { variaveisDoEnvFile } from './env-file-do-build.js';
+export const PUBLIC_SECRET_PATTERNS = [
+    { id: 'nrt_key', label: 'credencial nrt_ do produto (só de servidor)', re: /nrt_[A-Za-z0-9_-]{20,}/g },
+    { id: 'npk_key', label: 'chave npk_ do produto', re: /npk_[A-Za-z0-9_-]{20,}/g },
+    {
+        id: 'private_key',
+        label: 'chave privada PEM',
+        // Exige MATERIAL de chave depois do cabeçalho (base64, com quebra real ou
+        // `\n` escapado de string JS) — o cabeçalho sozinho aparece em código de
+        // biblioteca (ex.: validação de PEM do `jose`) e não é segredo.
+        re: /-----BEGIN (?:[A-Z0-9]+ )*PRIVATE KEY-----(?:\\[nr]|\s)*[A-Za-z0-9+/=]{40,}/g,
+    },
+];
+/** Prefixos de env que os bundlers injetam no código do navegador/app. */
+export const PUBLIC_ENV_PREFIXES = ['NEXT_PUBLIC_', 'EXPO_PUBLIC_', 'VITE_', 'REACT_APP_', 'PUBLIC_'];
+const SENSITIVE_ENV_NAME_RE = /KEY|SECRET|TOKEN/i;
+/** Valores curtos demais geram falso positivo em massa (ex.: "true", "1"). */
+const MIN_ENV_VALUE_LENGTH = 12;
+/** Formatos de valor que são públicos POR DESENHO do provedor. */
+const KNOWN_PUBLIC_VALUE_SHAPES = [
+    /^pk_(live|test)_[A-Za-z0-9]+$/, // Stripe publishable key
+    /^AIza[0-9A-Za-z_-]{35}$/, // Google/Firebase web API key (restrita por domínio)
+    /^6L[0-9A-Za-z_-]{38}$/, // reCAPTCHA site key
+];
+export function isKnownPublicValue(value) {
+    return KNOWN_PUBLIC_VALUE_SHAPES.some((re) => re.test(value));
+}
+export function isPublicSensitiveEnvName(name) {
+    return PUBLIC_ENV_PREFIXES.some((p) => name.startsWith(p)) && SENSITIVE_ENV_NAME_RE.test(name);
+}
+// ─── Máscara ────────────────────────────────────────────────────────────────
+/** Até 8 caracteres iniciais (nunca mais que 1/4 do valor) + máscara. */
+export function maskSecret(value) {
+    const shown = Math.min(8, Math.floor(value.length / 4));
+    return `${value.slice(0, shown)}…[mascarado, ${value.length} caracteres]`;
+}
+// ─── Caminhos públicos ──────────────────────────────────────────────────────
+const PUBLIC_TOP_DIRS = new Set(['public', 'out', 'dist', 'build']);
+/** Normaliza o nome de membro do tar: `\` → `/`, sem `./` nem `/` iniciais. */
+export function normalizeEntryPath(p) {
+    let s = p.replace(/\\/g, '/');
+    while (s.startsWith('./'))
+        s = s.slice(2);
+    s = s.replace(/^\/+/, '');
+    return s;
+}
+export function isPublicArtifactPath(relPath, stack) {
+    const p = normalizeEntryPath(relPath);
+    if (!p)
+        return false;
+    const segs = p.split('/');
+    if (segs.includes('node_modules'))
+        return false;
+    if (stack === 'static')
+        return true;
+    // `.next/static/**` em qualquer profundidade (monorepo: apps/web/.next/static).
+    for (let i = 0; i < segs.length - 1; i++) {
+        if (segs[i] === '.next' && segs[i + 1] === 'static')
+            return true;
+    }
+    return PUBLIC_TOP_DIRS.has(segs[0]) && segs.length > 1;
+}
+const BINARY_EXT = new Set([
+    '.png', '.jpg', '.jpeg', '.gif', '.webp', '.avif', '.ico', '.bmp', '.tif', '.tiff',
+    '.woff', '.woff2', '.ttf', '.otf', '.eot',
+    '.mp4', '.webm', '.mov', '.mp3', '.wav', '.ogg', '.m4a',
+    '.pdf', '.zip', '.gz', '.br', '.zst', '.7z', '.wasm',
+]);
+/** Arquivos maiores que isso não são varridos (e são reportados como não varridos). */
+export const MAX_SCAN_FILE_BYTES = 25 * 1024 * 1024;
+export function isScannableFile(relPath) {
+    return !BINARY_EXT.has(path.extname(relPath).toLowerCase());
+}
+// ─── Formas do valor da env dentro do pacote ────────────────────────────────
+const ESPECIAIS_DE_REGEX = /[.*+?^${}()|[\]\\]/g;
+/** Fonte de regex que casa `s` ao pé da letra (o caractere de controle cru casa ele mesmo). */
+function literalDeRegex(s) {
+    return s.replace(ESPECIAIS_DE_REGEX, '\\$&');
+}
+/** Hex de `n` com `digitos` no mínimo, cada letra casando nas duas caixas (`e1` → `[eE]1`). */
+function hexNasDuasCaixas(n, digitos) {
+    return n
+        .toString(16)
+        .padStart(digitos, '0')
+        .replace(/[a-f]/g, (c) => `[${c}${c.toUpperCase()}]`);
+}
+/**
+ * Escape curto que pode estar no pacote no lugar do caractere ASCII (texto do
+ * pacote, não da regex). Medido na rodada final 4 do cli#81, num `next build`
+ * real (Next 15.5.27) e no esbuild 0.28.1:
+ *   - `\\` (barra invertida): os dois;
+ *   - `\"` e `\'`: o SWC, quando o valor tem as duas aspas (o esbuild usa crase);
+ *   - `\/`: os dois, em `<\/script>`;
+ *   - `\n`: o SWC (o esbuild grava a quebra crua, dentro de crase);
+ *   - `\r`, `\b`, `\f`, `\v` e `\0`: os dois;
+ *   - `\$` (em `\${`) e a crase escapada: o esbuild (0.21.5 do Vite 5.4 e 0.28), quando
+ *     o valor tem as duas aspas repetidas e ele escolhe a crase (rodada final
+ *     5, medido num `vite build` real). O SWC não escapa nenhum dos dois.
+ * A tabulação não aparece como `\t`: os dois a gravam crua.
+ */
+const ESCAPE_CURTO = new Map([
+    [0x5c, '\\\\'],
+    [0x22, '\\"'],
+    [0x27, "\\'"],
+    [0x2f, '\\/'],
+    [0x0a, '\\n'],
+    [0x0d, '\\r'],
+    [0x08, '\\b'],
+    [0x0c, '\\f'],
+    [0x0b, '\\v'],
+    [0x00, '\\0'],
+    [0x24, '\\$'],
+    [0x60, '\\`'],
+]);
+/**
+ * O minificador pode gravar este caractere de outro jeito? Sim para letra fora
+ * do ASCII, caractere de controle (incluindo U+007F) e `\ " ' / $` e a crase.
+ * As demais letras ASCII saem sempre cruas.
+ */
+function podeSairEscapado(cp) {
+    return cp >= 0x7f || cp < 0x20 || ESCAPE_CURTO.has(cp);
+}
+/**
+ * Fonte de regex com todas as formas em que UM caractere que pode sair
+ * escapado estaria numa string JS do pacote. Medido nas rodadas finais 3 e 4
+ * do cli#81:
+ *   - cru: nos bytes UTF-8 (Vite 5.4, esbuild com `charset: "utf8"`, e o SWC
+ *     do Next 15.5 de U+0100 a U+FFFF), e o controle cru (a tabulação nos dois,
+ *     e a quebra dentro de crase no esbuild);
+ *   - o escape curto de `ESCAPE_CURTO`;
+ *   - `\xNN`, até U+00FF: o SWC do Next 15.5 (`\xe1`, `\x01`, `\x7f`) e o
+ *     esbuild no padrão (`\xE1`, `\x1B`, `\x7F`);
+ *   - `\uNNNN`, no resto do plano básico: o esbuild no padrão (`\u20AC`);
+ *   - o par `\uD83D\uDE00`, acima do plano básico: o SWC do Next 15.5;
+ *   - `\u{1F600}`: o esbuild no padrão com alvo ES2015 ou mais novo.
+ * O hex casa nas duas caixas, porque o SWC grava `\xe1` e `\uD83D`, e o
+ * esbuild grava `\xE1`.
+ *
+ * A barra invertida NÃO tem a forma crua aqui (rodada final 5): dentro de uma
+ * string JS uma barra crua sempre abre um escape, e a forma crua `\` é prefixo
+ * do escape `\\`. Com as duas, cada barra do valor casava uma ou duas barras do
+ * pacote: o tempo crescia 1,7 vez por barra (24 barras, 1,6 s) e um valor com
+ * duas barras casava o JS de uma. Sem ela, as formas de cada caractere
+ * começam diferentes, no máximo uma casa em cada posição e a busca é linear.
+ * A barra crua fora de JS e JSON é coberta à parte, em `valorApareceNoPacote`.
+ */
+function formasDaLetra(letra, emBytes) {
+    const cp = letra.codePointAt(0);
+    const crua = emBytes ? Buffer.from(letra, 'utf8').toString('latin1') : letra;
+    const formas = cp === 0x5c ? [] : [literalDeRegex(crua)];
+    const curto = ESCAPE_CURTO.get(cp);
+    if (curto)
+        formas.push(literalDeRegex(curto));
+    if (cp <= 0xff)
+        formas.push(`\\\\x${hexNasDuasCaixas(cp, 2)}`);
+    if (cp <= 0xffff)
+        formas.push(`\\\\u${hexNasDuasCaixas(cp, 4)}`);
+    if (cp > 0xffff) {
+        const alto = 0xd800 + ((cp - 0x10000) >> 10);
+        const baixo = 0xdc00 + ((cp - 0x10000) & 0x3ff);
+        formas.push(`\\\\u${hexNasDuasCaixas(alto, 4)}\\\\u${hexNasDuasCaixas(baixo, 4)}`);
+    }
+    formas.push(`\\\\u\\{0*${hexNasDuasCaixas(cp, 1)}\\}`);
+    return `(?:${formas.join('|')})`;
+}
+/**
+ * Regex que acha o valor no pacote com cada caractere que pode sair escapado
+ * em qualquer uma das suas formas, letra a letra: o SWC do Next mistura as
+ * formas dentro do MESMO valor (`chave-€-łódź` sai com `€`, `ł` e `ź` crus
+ * e `ó` como `\xf3`). `emBytes` diz se o pacote foi lido em latin1 (a forma
+ * crua é então a dos bytes UTF-8). Devolve `null` quando nenhum caractere do
+ * valor pode sair escapado: aí basta `includes`.
+ */
+export function padraoDoValorNoPacote(valor, emBytes) {
+    const letras = [...valor];
+    if (!letras.some((l) => podeSairEscapado(l.codePointAt(0))))
+        return null;
+    let fonte = '';
+    for (const letra of letras) {
+        fonte += podeSairEscapado(letra.codePointAt(0))
+            ? formasDaLetra(letra, emBytes)
+            : literalDeRegex(letra);
+    }
+    return new RegExp(fonte);
+}
+/**
+ * Arquivo em que o valor só pode estar dentro de string JS ou JSON: ali a barra
+ * invertida nunca aparece crua (uma barra crua sempre abre um escape).
+ */
+const BARRA_SEMPRE_ESCAPADA = new Set(['.js', '.mjs', '.cjs', '.json', '.map']);
+function valorApareceNoPacote(arquivo, texto, valor, emBytes) {
+    const padrao = padraoDoValorNoPacote(valor, emBytes);
+    if (!padrao)
+        return texto.includes(valor);
+    if (padrao.test(texto))
+        return true;
+    // Valor com barra invertida num arquivo que não é JS nem JSON (`.txt`,
+    // `.html`, `.css`…): o texto pode trazer a barra crua, que a regex não aceita.
+    if (!valor.includes('\\') || BARRA_SEMPRE_ESCAPADA.has(path.extname(arquivo).toLowerCase()))
+        return false;
+    return texto.includes(emBytes ? Buffer.from(valor, 'utf8').toString('latin1') : valor);
+}
+/**
+ * Varre um conteúdo de arquivo. Um achado por (arquivo, padrão): desde a
+ * rodada final 5 do cli#81 cada nome tem até três valores procurados (o do
+ * Next, o do Vite e o cru), e quando um é pedaço do outro os dois casavam. A
+ * busca do nome para no primeiro valor achado.
+ */
+export function scanContent(file, content, envSecrets) {
+    const text = typeof content === 'string' ? content : content.toString('latin1');
+    const out = [];
+    for (const pat of PUBLIC_SECRET_PATTERNS) {
+        pat.re.lastIndex = 0;
+        const m = pat.re.exec(text);
+        if (m)
+            out.push({ file, pattern: pat.id, label: pat.label, preview: maskSecret(m[0]) });
+    }
+    const nomesAchados = new Set();
+    for (const env of envSecrets) {
+        if (nomesAchados.has(env.name))
+            continue;
+        // Rodadas finais 2 a 4 do cli#81: o pacote vem em bytes e vira texto em
+        // latin1 (1 byte = 1 caractere), mas o valor da env é texto, e cada
+        // caractere fora do ASCII, de controle, barra invertida, aspa ou barra pode
+        // estar no pacote cru ou escapado — ver `padraoDoValorNoPacote`. Para valor
+        // só com letras ASCII comuns nada muda.
+        if (valorApareceNoPacote(file, text, env.value, typeof content !== 'string')) {
+            nomesAchados.add(env.name);
+            out.push({
+                file,
+                pattern: `public_env:${env.name}`,
+                label: `valor da env pública ${env.name} (nome com KEY/SECRET/TOKEN vai pro navegador)`,
+                preview: maskSecret(env.value),
+            });
+        }
+    }
+    return out;
+}
+// ─── Env pública com cara de segredo ────────────────────────────────────────
+/**
+ * Lê o .env com a regra do dotenv, a MESMA que o `@next/env` 15.5 e o Vite 5.4
+ * embutem (copiada dos dois no `node_modules` da core-deps; rodada final 4 do
+ * cli#81). A varredura procura no pacote o valor que o bundler leu, e o parser
+ * mínimo de antes divergia em quatro pontos, medidos num `next build` real:
+ *   - `CHAVE=valor # nota`: o dotenv corta no `#`; o parser antigo levava a nota;
+ *   - valor entre crases: o dotenv tira as crases; o antigo não;
+ *   - `CHAVE="a\nb"`: entre aspas duplas, o dotenv troca `\n` e `\r` pela
+ *     quebra de linha e pelo retorno; o antigo deixava a barra e a letra;
+ *   - valor entre aspas em mais de uma linha: o dotenv junta; o antigo cortava.
+ */
+export function parseDotenv(content) {
+    const LINHA = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+    const out = {};
+    const texto = content.replace(/\r\n?/gm, '\n');
+    let m;
+    while ((m = LINHA.exec(texto)) != null) {
+        let valor = (m[2] || '').trim();
+        const aspa = valor[0];
+        valor = valor.replace(/^(['"`])([\s\S]*)\1$/gm, '$2');
+        if (aspa === '"')
+            valor = valor.replace(/\\n/g, '\n').replace(/\\r/g, '\r');
+        out[m[1]] = valor;
+    }
+    return out;
+}
+/** Arquivos .env que o bundler lê num build de produção (o `.env*` NÃO viaja no tarball). */
+export const BUILD_ENV_FILES = ['.env', '.env.production', '.env.local', '.env.production.local'];
+// ─── Expansão de $VAR, que o bundler faz depois do parse ────────────────────
+//
+// Rodada final 5 do cli#81: o Next 15.5 (`@next/env`) e o Vite 5.4 (`loadEnv`)
+// expandem `$VAR`, `${VAR}` e `${VAR:-padrão}` depois de ler o `.env`, e é o
+// valor EXPANDIDO que vai ao JS do navegador. Medido num `next build` e num
+// `vite build` reais: com a busca pelo valor cru, 15 de 16 e 12 de 14 segredos
+// passavam. Os dois embutem versões DIFERENTES do dotenv-expand, com
+// resultados diferentes (no Vite, `$A-fim` lê o `-fim` como padrão e o some;
+// no Next, `${A:-x}` com o `A` só no mesmo arquivo dá `x`). As duas regras
+// estão copiadas abaixo, cada uma do seu `node_modules` na core-deps, e a
+// varredura procura os dois resultados, e o valor cru para bundler que não expande.
+/**
+ * Orçamento de substituições por valor e teto de tamanho do valor expandido.
+ * Um ciclo (`A=$B`, `B=$A`) estoura a pilha do bundler e derruba o build; aqui
+ * a expansão só para. Sem o teto, o valor de um ciclo crescia a cada passo e a
+ * varredura ficava sem memória (visto no teste do ciclo).
+ */
+const ORCAMENTO_DE_SUBSTITUICOES = 200;
+const TETO_DO_VALOR_EXPANDIDO = 32 * 1024;
+/** `_resolveEscapeSequences`, igual nos dois: `\$` vira `$`. */
+function resolverEscapeDoDolar(valor) {
+    return valor.replace(/\\\$/g, '$');
+}
+/** `_searchLast` do `@next/env` 15.5. */
+function ultimaPosicao(texto, re) {
+    const achados = Array.from(texto.matchAll(re));
+    return achados.length > 0 ? achados[achados.length - 1].index : -1;
+}
+/**
+ * `_interpolate` do `@next/env` 15.5, copiado: troca o `$` mais à direita sem
+ * barra antes, e repete. A ordem é a do Next, ambiente, depois padrão, depois
+ * o arquivo: com `${A:-x}`, um `A` que só existe no mesmo arquivo perde para o `x`.
+ */
+function interpolarComoONext(valor, ambiente, arquivo, orcamento = { resta: ORCAMENTO_DE_SUBSTITUICOES }) {
+    if (--orcamento.resta < 0 || valor.length > TETO_DO_VALOR_EXPANDIDO)
+        return valor;
+    const ultimo = ultimaPosicao(valor, /(?!(?<=\\))\$/g);
+    if (ultimo === -1)
+        return valor;
+    const m = valor.slice(ultimo).match(/((?!(?<=\\))\${?([\w]+)(?::-([^}\\]*))?}?)/);
+    if (m == null)
+        return valor;
+    const [, grupo, nome, padrao] = m;
+    return interpolarComoONext(valor.replace(grupo, ambiente[nome] || padrao || arquivo[nome] || ''), ambiente, arquivo, orcamento);
+}
+/** `expand` do `@next/env` 15.5: lê do ambiente, que é o `process.env` do build, e o altera ao fim de cada arquivo. */
+function expandirComoONext(arquivo, ambiente) {
+    for (const chave in arquivo) {
+        const valor = Object.prototype.hasOwnProperty.call(ambiente, chave) ? ambiente[chave] : arquivo[chave];
+        arquivo[chave] = resolverEscapeDoDolar(interpolarComoONext(valor, ambiente, arquivo));
+    }
+    for (const chave in arquivo)
+        ambiente[chave] = arquivo[chave];
+}
+/**
+ * O env do build no Next 15.5 (`loadEnvConfig` → `processEnv`): os arquivos vêm
+ * do de maior prioridade para o de menor, cada um expandido com o ambiente, e
+ * a chave que já está no ambiente do build não é trocada por arquivo nenhum.
+ */
+function envComoONextCarrega(arquivos, ambienteDoBuild) {
+    const ambiente = { ...ambienteDoBuild };
+    const dosArquivos = {};
+    for (const lido of arquivos) {
+        const arquivo = { ...lido };
+        expandirComoONext(arquivo, ambiente);
+        for (const chave of Object.keys(arquivo)) {
+            if (dosArquivos[chave] === undefined && ambienteDoBuild[chave] === undefined)
+                dosArquivos[chave] = arquivo[chave];
+        }
+    }
+    return Object.assign(ambiente, dosArquivos);
+}
+/** `DOTENV_SUBSTITUTION_REGEX` do dotenv-expand que o Vite 5.4 embute, copiada. */
+const SUBSTITUICAO_DO_VITE = /(\\)?(\$)(?!\()(\{?)([\w.]+)(?::?-((?:\$\{(?:\$\{(?:\$\{[^}]*\}|[^}])*}|[^}])*}|[^}])+))?(\}?)/gi;
+/**
+ * `interpolate` do Vite 5.4, copiado. Difere do Next: troca da esquerda para a
+ * direita, aceita `-padrão` sem os dois-pontos (por isso `$A-fim` vira só o
+ * valor de `A`) e prefere o ambiente, depois o arquivo, depois o padrão.
+ */
+function interpolarComoOVite(valor, ambiente, arquivo, orcamento = { resta: ORCAMENTO_DE_SUBSTITUICOES }) {
+    if (--orcamento.resta < 0 || valor.length > TETO_DO_VALOR_EXPANDIDO)
+        return valor;
+    return valor.replace(SUBSTITUICAO_DO_VITE, (casado, escapado, _dolar, _abre, chave, padrao) => {
+        if (escapado === '\\')
+            return casado.slice(1);
+        if (ambiente[chave]) {
+            if (ambiente[chave] === arquivo[chave])
+                return ambiente[chave];
+            return interpolarComoOVite(ambiente[chave], ambiente, arquivo, orcamento);
+        }
+        if (arquivo[chave]) {
+            if (arquivo[chave] === valor)
+                return arquivo[chave];
+            return interpolarComoOVite(arquivo[chave], ambiente, arquivo, orcamento);
+        }
+        if (padrao) {
+            if (padrao.startsWith('$'))
+                return interpolarComoOVite(padrao, ambiente, arquivo, orcamento);
+            return padrao;
+        }
+        return '';
+    });
+}
+/** `expand` do Vite 5.4: a chave que o ambiente já tem com OUTRO valor fica com o do ambiente, sem expandir. */
+function expandirComoOVite(arquivo, ambiente) {
+    for (const chave in arquivo) {
+        let valor = arquivo[chave];
+        if (Object.prototype.hasOwnProperty.call(ambiente, chave)) {
+            valor = ambiente[chave] === arquivo[chave] ? interpolarComoOVite(valor, ambiente, arquivo) : ambiente[chave];
+        }
+        else {
+            valor = interpolarComoOVite(valor, ambiente, arquivo);
+        }
+        arquivo[chave] = resolverEscapeDoDolar(valor);
+    }
+    for (const chave in arquivo)
+        ambiente[chave] = arquivo[chave];
+}
+/**
+ * O env que o Vite 5.4 expõe (`loadEnv`): junta os arquivos, o de maior
+ * prioridade por último; expande uma vez, com uma CÓPIA do ambiente do build;
+ * e a variável do ambiente do build vence a do arquivo.
+ */
+function envComoOViteCarrega(arquivos, ambienteDoBuild) {
+    const arquivo = Object.fromEntries(arquivos.flatMap((a) => Object.entries(a)));
+    expandirComoOVite(arquivo, { ...ambienteDoBuild });
+    return { ...arquivo, ...ambienteDoBuild };
+}
+/**
+ * Coleta envs públicas com nome sensível a partir do ambiente do build:
+ * `.env*` do projeto, `--env-file` e `process.env` do CLI (o build roda com ele).
+ *
+ * Rodada final 2 do cli#81: cada arquivo é lido COMO O BUNDLER O LÊ, porque a
+ * varredura procura no pacote o valor que o bundler gravou lá. O `@next/env`
+ * (Next 15.5) lê o `.env` com `readFileSync(…, "utf8")` e o Vite 5.4 passa os
+ * bytes ao `dotenv`, que faz `toString()`: os dois trocam byte que não é UTF-8
+ * por U+FFFD, e é esse valor trocado que vai ao JS do navegador. Por isso aqui
+ * a leitura NÃO recusa (como faz o `--env-file`, que a CLI injeta ela mesma):
+ * recusar esconderia o valor que de fato está no pacote. Em vez de passar
+ * calado, `aoLerForaDeUtf8` recebe cada arquivo que não é UTF-8 limpo, para o
+ * deploy avisar que o app vai receber outro valor.
+ *
+ * Rodada final 5: o `--env-file` não é um `.env` que o bundler lê. O
+ * `neetru build` o injeta no ambiente do processo do build, com a regra
+ * própria da CLI (`variaveisDoEnvFile`). Por isso ele entra aqui como ambiente:
+ * vence os arquivos, serve de fonte para a expansão e não é expandido. Cada
+ * valor é procurado como o Next o deixa, como o Vite o deixa e cru.
+ */
+export async function collectPublicEnvSecrets(cwd, envFile, processEnv = process.env, aoLerForaDeUtf8) {
+    const lidos = new Map();
+    for (const nome of BUILD_ENV_FILES) {
+        let bruto;
+        try {
+            bruto = await fsp.readFile(path.join(cwd, nome));
+        }
+        catch {
+            continue; /* arquivo ausente/ilegível — ignora */
+        }
+        const problema = problemaDeCodificacao(bruto);
+        if (problema)
+            aoLerForaDeUtf8?.(nome, problema);
+        lidos.set(nome, parseDotenv(bruto.toString('utf8')));
+    }
+    // O ambiente do processo do build: o da CLI e, por cima, o `--env-file`.
+    const ambiente = {};
+    for (const [k, v] of Object.entries(processEnv)) {
+        if (typeof v === 'string')
+            ambiente[k] = v;
+    }
+    if (envFile) {
+        const caminho = path.resolve(cwd, envFile);
+        let bruto;
+        try {
+            bruto = await fsp.readFile(caminho);
+        }
+        catch {
+            bruto = undefined; /* ausente/ilegível — ignora */
+        }
+        if (bruto) {
+            const problema = problemaDeCodificacao(bruto);
+            if (problema)
+                aoLerForaDeUtf8?.(path.relative(cwd, caminho) || caminho, problema);
+            Object.assign(ambiente, variaveisDoEnvFile(semBomInicial(bruto.toString('utf8'))));
+        }
+    }
+    const emOrdem = (nomes) => nomes.flatMap((n) => {
+        const lido = lidos.get(n);
+        return lido ? [lido] : [];
+    });
+    // Cru: do de menor para o de maior prioridade (o `.env.local` vence o `.env.production`), e o ambiente por cima.
+    const cru = Object.assign({}, ...emOrdem(BUILD_ENV_FILES), ambiente);
+    const comoONext = envComoONextCarrega(emOrdem(['.env.production.local', '.env.local', '.env.production', '.env']), ambiente);
+    const comoOVite = envComoOViteCarrega(emOrdem(['.env', '.env.local', '.env.production', '.env.production.local']), ambiente);
+    const seen = new Set();
+    const out = [];
+    for (const fonte of [cru, comoONext, comoOVite]) {
+        for (const [name, value] of Object.entries(fonte)) {
+            if (!isPublicSensitiveEnvName(name))
+                continue;
+            if (value.length < MIN_ENV_VALUE_LENGTH || isKnownPublicValue(value))
+                continue;
+            const key = `${name}\u0000${value}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push({ name, value });
+        }
+    }
+    return out;
+}
+function readString(buf, start, len) {
+    const slice = buf.subarray(start, start + len);
+    const nul = slice.indexOf(0);
+    return slice.subarray(0, nul < 0 ? slice.length : nul).toString('utf8');
+}
+function readSize(buf) {
+    const field = buf.subarray(124, 136);
+    if (field[0] & 0x80) {
+        // base-256 (GNU, arquivos > 8 GiB)
+        let n = 0;
+        for (let i = 1; i < field.length; i++)
+            n = n * 256 + field[i];
+        return n;
+    }
+    const s = readString(buf, 124, 12).trim();
+    return s ? parseInt(s, 8) : 0;
+}
+function parseHeader(block) {
+    const name = readString(block, 0, 100);
+    const type = String.fromCharCode(block[156] || 48); // '\0' → '0'
+    const magic = readString(block, 257, 6);
+    const prefix = magic.startsWith('ustar') ? readString(block, 345, 155) : '';
+    return { name: prefix ? `${prefix}/${name}` : name, size: readSize(block), type };
+}
+function parsePaxPath(data) {
+    const text = data.toString('utf8');
+    let i = 0;
+    while (i < text.length) {
+        const sp = text.indexOf(' ', i);
+        if (sp < 0)
+            break;
+        const len = parseInt(text.slice(i, sp), 10);
+        if (!Number.isFinite(len) || len <= 0)
+            break;
+        const record = text.slice(sp + 1, i + len - 1); // sem o '\n' final
+        const eq = record.indexOf('=');
+        if (eq > 0 && record.slice(0, eq) === 'path')
+            return record.slice(eq + 1);
+        i += len;
+    }
+    return null;
+}
+const META_MAX_BYTES = 1024 * 1024;
+/**
+ * Lê um .tar.gz em streaming e chama `onFile` para cada arquivo regular que
+ * `want(nome, tamanho)` aceitar. Arquivos não desejados são pulados sem buffer.
+ */
+export async function walkTarGz(tarPath, want, onFile) {
+    let buf = Buffer.alloc(0);
+    let state = 'header';
+    let remaining = 0;
+    let pad = 0;
+    let cur = null;
+    let longName = null;
+    let paxPath = null;
+    let ended = false;
+    const finish = () => {
+        if (!cur)
+            return;
+        const data = cur.chunks ? Buffer.concat(cur.chunks) : null;
+        if (cur.type === 'L' && data) {
+            longName = readString(data, 0, data.length);
+        }
+        else if (cur.type === 'x' && data) {
+            paxPath = parsePaxPath(data) ?? paxPath;
+        }
+        else if ((cur.type === '0' || cur.type === '7') && data) {
+            onFile(cur.name, data);
+        }
+        cur = null;
+    };
+    const consume = () => {
+        let off = 0;
+        for (;;) {
+            if (ended) {
+                off = buf.length;
+                break;
+            }
+            if (state === 'header') {
+                if (buf.length - off < 512)
+                    break;
+                const block = buf.subarray(off, off + 512);
+                off += 512;
+                if (block.every((b) => b === 0))
+                    continue; // bloco zero (fim/padding)
+                const h = parseHeader(block);
+                let name = h.name;
+                const isMeta = h.type === 'L' || h.type === 'x' || h.type === 'g' || h.type === 'K';
+                if (!isMeta) {
+                    name = paxPath ?? longName ?? name;
+                    paxPath = null;
+                    longName = null;
+                }
+                const regular = h.type === '0' || h.type === '7';
+                let collect = false;
+                if (h.type === 'L' || h.type === 'x')
+                    collect = h.size <= META_MAX_BYTES;
+                else if (regular)
+                    collect = want(name, h.size);
+                cur = { name, type: h.type, chunks: collect ? [] : null };
+                remaining = h.size;
+                pad = (512 - (h.size % 512)) % 512;
+                if (remaining === 0) {
+                    finish();
+                    state = pad ? 'pad' : 'header';
+                }
+                else {
+                    state = 'data';
+                }
+            }
+            else if (state === 'data') {
+                const avail = buf.length - off;
+                if (avail === 0)
+                    break;
+                const take = Math.min(avail, remaining);
+                if (cur?.chunks)
+                    cur.chunks.push(Buffer.from(buf.subarray(off, off + take)));
+                off += take;
+                remaining -= take;
+                if (remaining === 0) {
+                    finish();
+                    state = pad ? 'pad' : 'header';
+                }
+            }
+            else {
+                const avail = buf.length - off;
+                if (avail === 0)
+                    break;
+                const take = Math.min(avail, pad);
+                off += take;
+                pad -= take;
+                if (pad === 0)
+                    state = 'header';
+            }
+        }
+        buf = buf.subarray(off);
+    };
+    await new Promise((resolve, reject) => {
+        const input = fs.createReadStream(tarPath);
+        const gunzip = zlib.createGunzip();
+        input.on('error', reject);
+        gunzip.on('error', (e) => reject(new Error(`pacote .tar.gz ilegível: ${e.message}`)));
+        gunzip.on('data', (chunk) => {
+            buf = buf.length ? Buffer.concat([buf, chunk]) : chunk;
+            try {
+                consume();
+            }
+            catch (e) {
+                ended = true;
+                reject(e);
+            }
+        });
+        gunzip.on('end', () => resolve());
+        input.pipe(gunzip);
+    });
+}
+/** Varre o tarball de deploy (o que de fato vai pro GCS). */
+export async function scanTarballForPublicSecrets(tarPath, ctx) {
+    const findings = [];
+    const skippedLarge = [];
+    let scannedFiles = 0;
+    await walkTarGz(tarPath, (name, size) => {
+        if (!isPublicArtifactPath(name, ctx.stack) || !isScannableFile(name))
+            return false;
+        if (size > MAX_SCAN_FILE_BYTES) {
+            skippedLarge.push(normalizeEntryPath(name));
+            return false;
+        }
+        return true;
+    }, (name, data) => {
+        scannedFiles++;
+        findings.push(...scanContent(normalizeEntryPath(name), data, ctx.envSecrets));
+    });
+    return { findings, scannedFiles, skippedLarge };
+}
+/** Varre as pastas públicas no disco (target=cloud-run, onde não há tarball). */
+export async function scanDirectoryForPublicSecrets(root, ctx) {
+    const findings = [];
+    const skippedLarge = [];
+    let scannedFiles = 0;
+    const starts = ctx.stack === 'static'
+        ? ['.']
+        : ['.next/static', ...PUBLIC_TOP_DIRS].filter((d) => {
+            try {
+                return fs.statSync(path.join(root, d)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+    async function walk(rel) {
+        let entries;
+        try {
+            entries = await fsp.readdir(path.join(root, rel), { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const childRel = rel === '.' ? e.name : `${rel}/${e.name}`;
+            if (e.isSymbolicLink())
+                continue;
+            if (e.isDirectory()) {
+                if (e.name === 'node_modules' || e.name === '.git')
+                    continue;
+                await walk(childRel);
+            }
+            else if (e.isFile()) {
+                if (!isPublicArtifactPath(childRel, ctx.stack) || !isScannableFile(childRel))
+                    continue;
+                const abs = path.join(root, childRel);
+                const st = await fsp.stat(abs);
+                if (st.size > MAX_SCAN_FILE_BYTES) {
+                    skippedLarge.push(childRel);
+                    continue;
+                }
+                scannedFiles++;
+                findings.push(...scanContent(childRel, await fsp.readFile(abs), ctx.envSecrets));
+            }
+        }
+    }
+    for (const s of starts)
+        await walk(s);
+    return { findings, scannedFiles, skippedLarge };
+}
+// ─── Mensagens ──────────────────────────────────────────────────────────────
+export const ALLOW_PUBLIC_SECRET_FLAG = '--allow-public-secret';
+/** Motivo mínimo do override (evita `--allow-public-secret x`). */
+export const MIN_OVERRIDE_REASON_LENGTH = 10;
+export function formatFindingsMessage(findings) {
+    const lines = findings
+        .slice(0, 20)
+        .map((f) => `  - ${f.file} — ${f.label} (${f.preview})`);
+    const more = findings.length > 20 ? [`  … e mais ${findings.length - 20} achado(s).`] : [];
+    return [
+        `Segredo no pacote PÚBLICO (servido ao navegador): ${findings.length} achado(s). Deploy BLOQUEADO.`,
+        ...lines,
+        ...more,
+        '',
+        'Por quê: tudo em .next/static, public, out, dist e build é baixado por qualquer visitante — ',
+        'a chave vira pública na hora. A credencial nrt_ do produto é SÓ DE SERVIDOR.',
+        'Como corrigir:',
+        '  1. Tire a chave do código do navegador/app: nada de NEXT_PUBLIC_*_KEY/EXPO_PUBLIC_*_KEY com segredo.',
+        '  2. O navegador/app chama a API do SEU produto (/api/v1/...) com o token do usuário;',
+        '     o backend usa @neetru/sdk com NEETRU_API_KEY (injetada no servidor pelo Core).',
+        '  3. Rode `neetru build` de novo e repita o deploy.',
+        `Emergência (fica registrado no deploy): ${ALLOW_PUBLIC_SECRET_FLAG} "<motivo>"`,
+    ].join('\n');
+}
+/** Registro do override — só caminho e tipo de padrão, NUNCA o valor. */
+export function buildOverrideRecord(reason, findings, now = new Date()) {
+    return {
+        reason,
+        findings: findings.map((f) => ({ file: f.file, pattern: f.pattern })),
+        at: now.toISOString(),
+    };
+}
+//# sourceMappingURL=public-secret-scan.js.map