@neetru/cli 2.31.0 → 2.32.0

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

@@ -33,6 +33,8 @@ 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 },
@@ -105,7 +107,141 @@ export const MAX_SCAN_FILE_BYTES = 25 * 1024 * 1024;
 export function isScannableFile(relPath) {
     return !BINARY_EXT.has(path.extname(relPath).toLowerCase());
 }
-/** Varre um conteúdo de arquivo. Dedup por (arquivo, padrão). */
+// ─── 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 = [];
@@ -115,8 +251,17 @@ export function scanContent(file, content, envSecrets) {
         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 (text.includes(env.value)) {
+        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}`,
@@ -128,61 +273,241 @@ export function scanContent(file, content, envSecrets) {
     return out;
 }
 // ─── Env pública com cara de segredo ────────────────────────────────────────
-/** Parser mínimo de .env (KEY=VALUE, aspas simples/duplas, comentários). */
+/**
+ * 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 = {};
-    for (const line of content.split(/\r?\n/)) {
-        const t = line.trim();
-        if (!t || t.startsWith('#'))
-            continue;
-        const body = t.startsWith('export ') ? t.slice(7) : t;
-        const eq = body.indexOf('=');
-        if (eq <= 0)
-            continue;
-        const k = body.slice(0, eq).trim();
-        let v = body.slice(eq + 1).trim();
-        if (v.length >= 2 && ((v[0] === '"' && v.endsWith('"')) || (v[0] === "'" && v.endsWith("'")))) {
-            v = v.slice(1, -1);
-        }
-        out[k] = v;
+    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) {
-    const merged = {};
-    const files = BUILD_ENV_FILES.map((f) => path.join(cwd, f));
-    if (envFile)
-        files.push(path.resolve(cwd, envFile));
-    for (const f of files) {
+export async function collectPublicEnvSecrets(cwd, envFile, processEnv = process.env, aoLerForaDeUtf8) {
+    const lidos = new Map();
+    for (const nome of BUILD_ENV_FILES) {
+        let bruto;
         try {
-            Object.assign(merged, parseDotenv(await fsp.readFile(f, 'utf8')));
+            bruto = await fsp.readFile(path.join(cwd, nome));
         }
         catch {
-            /* arquivo ausente/ilegível — ignora */
+            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')
-            merged[k] = v;
+            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 [name, value] of Object.entries(merged)) {
-        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 });
+    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;
 }

package/dist/lib/render.d.ts

@@ -4,7 +4,23 @@ export interface TableColumn<T> {
     value: (row: T) => string;
     /** Largura máxima da coluna (trunca com `…`). Default: 40. */
     maxWidth?: number;
+    /**
+     * A célula é um IDENTIFICADOR que o usuário copia pra outro comando
+     * (`show`, `get`, `claim`…). Nunca é cortada — `maxWidth` é ignorado.
+     *
+     * 2026-10-12: as colunas ID tinham `maxWidth` de 18 a 36, mas `bug_` tem 36
+     * caracteres, `tkt_<uuid>` 40 e `tenant_<uuid>` 43. A tabela imprimia um id
+     * que NÃO EXISTE (`bug_a4f84c1b0184448cbb0…`), o usuário copiava, e o comando
+     * seguinte respondia "não encontrado" — negando a existência de algo que
+     * existe. Um id cortado não é um id mais curto; é um id falso.
+     *
+     * Célula com FORMA de identificador já não é cortada mesmo sem esta opção
+     * (ver `pareceIdentificador`). A opção continua valendo para deixar a
+     * intenção explícita na coluna e para um id que um dia não tenha essa forma.
+     */
+    identificador?: boolean;
 }
+export declare function pareceIdentificador(celula: string): boolean;
 /**
  * Imprime uma tabela. Quando `rows` está vazio, imprime uma linha discreta.
  */

package/dist/lib/render.js

@@ -5,6 +5,30 @@
  * largura máxima de cada uma, trunca células longas e pinta o header.
  */
 import chalk from 'chalk';
+// eslint-disable-next-line no-control-regex
+const ANSI = /\u001b\[[0-9;]*m/g;
+/**
+ * Forma de IDENTIFICADOR: um token só, sem espaço, começando por letra ou
+ * dígito — `bug_<hex>`, `tkt_<uuid>`, `tenant_<uuid>`, uid do Firebase (28),
+ * auto-id do Firestore (20), slug, e-mail, `host:porta`, caminho relativo.
+ *
+ * Revisão do PR #75: a guarda de fonte (`id-que-existe.test.ts`) só via a
+ * coluna escrita do jeito que a regex dela espera, e deixou passar a
+ * RESPONSÁVEL do `bug list` (uid de 28 cortado em 24, que `--assigned-to`
+ * aceita de volta). Decidir aqui, pelo DADO, protege a próxima coluna sem
+ * depender de como alguém a escreveu (`maxWidth` ausente, coluna em várias
+ * linhas, `chalk.cyan(r.id)`, `r.slug ?? r.id`…).
+ *
+ * Custo aceito: um slug longo, um e-mail, um hash ou uma URL (sem `?`, `&`,
+ * `=`, que a regex não aceita) também deixam de ser cortados e podem alargar
+ * a tabela. Também são handles que alguém copia; cortados, seriam tão falsos
+ * quanto um id cortado. Texto com espaço (título, descrição, mensagem)
+ * continua truncando no `maxWidth`.
+ */
+const FORMA_DE_IDENTIFICADOR = /^[A-Za-z0-9][A-Za-z0-9_.:@\/-]*$/;
+export function pareceIdentificador(celula) {
+    return FORMA_DE_IDENTIFICADOR.test(celula.replace(ANSI, ''));
+}
 function truncate(s, max) {
     if (s.length <= max)
         return s;
@@ -12,10 +36,10 @@ function truncate(s, max) {
         return s.slice(0, max);
     return `${s.slice(0, max - 1)}…`;
 }
-// Comprimento visível ignorando ANSI escapes (chalk).
+// Comprimento visível ignorando ANSI escapes (chalk) — a mesma `ANSI` que
+// `pareceIdentificador` usa, em vez de uma segunda cópia da regex.
 function visibleLength(s) {
-    // eslint-disable-next-line no-control-regex
-    return s.replace(/\[[0-9;]*m/g, '').length;
+    return s.replace(ANSI, '').length;
 }
 function padEndVisible(s, width) {
     const len = visibleLength(s);
@@ -29,7 +53,13 @@ export function renderTable(columns, rows) {
         console.log(chalk.dim('  (nenhum resultado)'));
         return;
     }
-    const cells = rows.map((row) => columns.map((col) => truncate(col.value(row) ?? '', col.maxWidth ?? 40)));
+    const cells = rows.map((row) => columns.map((col) => {
+        const celula = col.value(row) ?? '';
+        // Identificador nunca é cortado: pela opção da coluna OU pela forma do dado.
+        if (col.identificador || pareceIdentificador(celula))
+            return celula;
+        return truncate(celula, col.maxWidth ?? 40);
+    }));
     const widths = columns.map((col, i) => {
         const headerLen = col.header.length;
         const maxCell = cells.reduce((m, r) => Math.max(m, visibleLength(r[i])), 0);

package/dist/lib/segredo-produto.d.ts

@@ -0,0 +1,124 @@
+export { CARACTERE_DE_TROCA, CodificacaoInvalida, decodificarUtf8, semBomInicial, type OrigemDosBytes, } from './texto-utf8.js';
+/**
+ * Aviso de que o segredo registrado ainda não chega ao app na VM. Com data:
+ * quando o agente for liberado, a frase fica visivelmente velha em vez de
+ * mentir calada. Mesmo fato que o Core declara no `assertNoSecretEnvVars`.
+ */
+export declare const AVISO_AGENTE_PENDENTE: string;
+/**
+ * O comando que registra `chave` no ambiente do deploy. `env` é o `--env` cru
+ * do deploy (`dev`, `production`…): sai no nome canônico que o Core aceita, ou
+ * `<ambiente>` quando não dá para saber.
+ */
+export declare function comandoParaRegistrarSegredo(chave: string, env: string | undefined): string;
+/** Nome de variável de ambiente em CAIXA_ALTA, 2 a 64 caracteres. */
+export declare const CHAVE_SEGREDO_RE: RegExp;
+/** Teto do valor: o do arquivo de ambiente que o agente escreve na VM. */
+export declare const TETO_VALOR_BYTES = 4096;
+/** Entropia aceita no `--generate` (bytes sorteados pelo Core). */
+export declare const BYTES_GERADO_MIN = 16;
+export declare const BYTES_GERADO_MAX = 128;
+/**
+ * Teto do que se aceita LER (arquivo/stdin) antes de validar. Bem acima do
+ * `TETO_VALOR_BYTES` para a mensagem de "grande demais" sair certa, e baixo o
+ * bastante para um `--from-file` apontado por engano para um arquivo enorme
+ * (ou que nunca acaba, como `/dev/zero`) não encher a memória: a leitura para
+ * em `TETO_LEITURA_BYTES + 1` bytes, nunca lê o arquivo inteiro.
+ */
+export declare const TETO_LEITURA_BYTES: number;
+/**
+ * Variáveis que o Core e o agente JÁ entregam ao app na VM, por outro canal.
+ * Espelho de `CORE_INJECTED_ENV_KEYS` (`neetru_core/src/lib/core-injected-env.ts`),
+ * na mesma ordem: o teste `reservadas de hoje` trava o literal e a conferência
+ * opt-in (`NEETRU_CORE_DIR`) compara com o Core.
+ */
+export declare const CHAVES_INJETADAS_PELO_CORE: readonly string[];
+/** Famílias inteiras entregues por um canal do Core (hoje: módulos). Espelho de `CORE_INJECTED_ENV_PREFIXES`. */
+export declare const PREFIXOS_INJETADOS_PELO_CORE: readonly string[];
+/**
+ * Variáveis que mudam como o processo carrega código: um "segredo" com esse
+ * nome é execução de código na VM. Espelho de `LOADER_ENV_KEYS` do Core.
+ */
+export declare const CHAVES_DO_CARREGADOR: readonly string[];
+/** O Core já entrega esta variável ao app na VM (nome exato ou família)? */
+export declare function chaveInjetadaPeloCore(chave: string): boolean;
+/**
+ * Por que o Core recusaria registrar esta chave como segredo do produto, ou
+ * `null` se ele aceita. Só chama depois de `problemaNaChave` aprovar o
+ * formato. Espelho de `assertValidProductSecretKey` (a parte da reserva).
+ *
+ * Revisão do #81 (M1): sem isto, a CLI pedia o valor, mandava, e só então o
+ * Core dizia "reservada". O nome exato é repetido na mensagem porque é um nome
+ * da lista fixa; a família `NEETRU_MODULE_` é citada pelo prefixo, sem
+ * repetir o resto do que foi digitado.
+ */
+export declare function problemaNaChaveReservada(chave: string): string | null;
+/**
+ * Por que a chave é recusada, ou `null` se serve. NUNCA repete o que foi
+ * digitado: `KEY=valor` e o valor colado no lugar do nome são os dois erros
+ * mais prováveis, e ecoar a entrada imprimiria o segredo.
+ */
+export declare function problemaNaChave(chave: string | undefined): string | null;
+/**
+ * Por que o valor é recusado, ou `null` se serve. Mesma regra do Core e do
+ * agente: o valor vira uma linha de `EnvironmentFile` do systemd, e o agente
+ * recusa a resposta INTEIRA (todos os segredos do produto) se um valor tiver
+ * quebra de linha, NUL, aspas, barra invertida ou espaço nas pontas.
+ */
+export declare function problemaNoValor(valor: string): string | null;
+/** Valida `--bytes` (só faz sentido com `--generate`). `null` se serve. */
+export declare function problemaNosBytes(bytes: number): string | null;
+/**
+ * Tira UMA quebra de linha do fim (`\n` ou `\r\n`) — a que `echo`, `cat` e
+ * os editores deixam. Só uma: o resto de espaço ou quebra nas pontas é
+ * recusado por `problemaNoValor`, com mensagem, em vez de ser "consertado"
+ * em silêncio (cortar demais grava um segredo diferente do que o dev tem).
+ */
+export declare function semQuebraFinal(texto: string): string;
+/**
+ * Texto que OUTRO decodificador já converteu (o `readline` do pedido na tela,
+ * ou um fluxo com `setEncoding`): os bytes originais se perderam e o U+FFFD é
+ * o único rastro de byte que não era UTF-8. Recusa quando ele aparece.
+ * Limite declarado: um U+FFFD digitado de propósito também é recusado — por
+ * esta porta não dá para distinguir.
+ */
+export declare function problemaNoTextoDoTerminal(texto: string): string | null;
+/** O mínimo de um arquivo aberto que a leitura usa (o `FileHandle` do Node; trocável no teste). */
+export interface ArquivoAberto {
+    read(buffer: Buffer, offset: number, length: number, position: number | null): Promise<{
+        bytesRead: number;
+    }>;
+    close(): Promise<void>;
+}
+/**
+ * Lê o valor de um arquivo. Erro de leitura vira mensagem sem conteúdo e sem
+ * o caminho (revisão do #81, B2: `--from-file <valor>` repetia o valor em
+ * "Arquivo não encontrado: <valor>").
+ *
+ * Lê no máximo `TETO_LEITURA_BYTES + 1` bytes (revisão do #81: o `readFile`
+ * de antes punha o arquivo inteiro na memória antes de conferir o teto).
+ */
+export declare function lerValorDeArquivo(caminho: string, abrir?: (caminho: string) => Promise<ArquivoAberto>): Promise<string>;
+/** Lê o valor inteiro de um fluxo (a entrada padrão, no `--stdin`). */
+export declare function lerValorDeFluxo(fluxo: NodeJS.ReadableStream): Promise<string>;
+/** Pedido cancelado (Ctrl+C ou fim da entrada antes da resposta). */
+export declare class PedidoCancelado extends Error {
+    constructor();
+}
+export interface FluxosDoPedido {
+    /** De onde vêm as teclas (o terminal). */
+    entrada: NodeJS.ReadableStream;
+    /** Onde a PERGUNTA aparece. Nunca recebe o que é digitado. */
+    saida: NodeJS.WritableStream;
+}
+/**
+ * Faz as perguntas SEM ECO, numa interface só (duas interfaces seguidas no
+ * mesmo fluxo perdem a linha que a primeira já tinha lido).
+ *
+ * Como o eco some: o `readline` desenha o que é digitado no `output` dele —
+ * aqui um fluxo MUDO, que descarta tudo. A pergunta vai direto para `saida`,
+ * fora do `readline`. Com `terminal: true` o `readline` também liga o modo
+ * cru do terminal (`setRawMode`), então nem o eco do próprio sistema
+ * operacional aparece.
+ */
+export declare function perguntarSemEco(perguntas: string[], fluxos: FluxosDoPedido): Promise<string[]>;