@neetru/cli 2.29.0 → 2.32.0

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[]>;

package/dist/lib/segredo-produto.js

@@ -0,0 +1,336 @@
+/**
+ * Entrada e validação do VALOR de um segredo próprio do produto
+ * (bug_8b85353b, Parte 3 — `neetru secrets`).
+ *
+ * REGRA DURA que molda este módulo: o valor NUNCA vem da linha de comando.
+ * Tudo o que vai no argv fica no histórico do shell (`~/.bash_history`,
+ * `PSReadLine`), aparece em `ps`/Gerenciador de Tarefas para qualquer
+ * processo da máquina e costuma ir parar em log de CI. Por isso o valor só
+ * entra por três portas:
+ *
+ *   1. `--stdin`              — lido da entrada padrão (pipe);
+ *   2. `--from-file <caminho>` — lido de um arquivo;
+ *   3. prompt SEM ECO         — o terminal não mostra o que é digitado.
+ *
+ * (A quarta saída — `--generate` — nem passa por aqui: o Core sorteia o valor
+ * e ninguém o vê.)
+ *
+ * E o valor NUNCA é impresso: nenhuma mensagem deste módulo repete o que foi
+ * digitado — nem quando a entrada está errada, porque a entrada errada pode
+ * ser justamente o valor colado no lugar do nome.
+ *
+ * Espelhos do Core (`neetru_core/src/lib/product-secrets.ts`, origin/main):
+ * `CHAVE_SEGREDO_RE` = `PRODUCT_SECRET_KEY_RE`, `TETO_VALOR_BYTES` =
+ * `PRODUCT_SECRET_MAX_VALUE_BYTES`, `problemaNoValor` = `productSecretValueProblem`,
+ * `BYTES_GERADO_*` = os limites de `generateProductSecretValue`, e
+ * `problemaNaChaveReservada` = `isReservedProductSecretKey` (listas de
+ * `core-injected-env.ts`). Validar aqui também é para o valor recusado não
+ * sair da máquina. Se o Core mudar a regra, ele continua sendo o juiz final —
+ * aqui é só falhar mais cedo.
+ */
+import { open } from 'node:fs/promises';
+import { createInterface } from 'node:readline';
+import { Writable } from 'node:stream';
+import { normalizarAmbienteTenant } from './envs.js';
+import { CARACTERE_DE_TROCA, decodificarUtf8, recusaNaoUtf8, semBomInicial } from './texto-utf8.js';
+// A leitura estrita em UTF-8 mora em `texto-utf8.ts` (o `--env-file` do deploy e do build usa a
+// mesma). Reexportada para quem já importava daqui.
+export { CARACTERE_DE_TROCA, CodificacaoInvalida, decodificarUtf8, semBomInicial, } 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 const AVISO_AGENTE_PENDENTE = 'Atenção: em 2026-10-16 o agente da VM ainda não entrega segredos do produto ao app ' +
+    '(Parte 2 de bug_8b85353b). O registro já vale e passa a chegar ao app no primeiro ' +
+    'deploy depois que o agente for atualizado.';
+/**
+ * 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 function comandoParaRegistrarSegredo(chave, env) {
+    return `neetru secrets set ${chave} --env ${normalizarAmbienteTenant(env) ?? '<ambiente>'}`;
+}
+/** Nome de variável de ambiente em CAIXA_ALTA, 2 a 64 caracteres. */
+export const CHAVE_SEGREDO_RE = /^[A-Z][A-Z0-9_]{1,63}$/;
+/** Teto do valor: o do arquivo de ambiente que o agente escreve na VM. */
+export const TETO_VALOR_BYTES = 4096;
+/** Entropia aceita no `--generate` (bytes sorteados pelo Core). */
+export const BYTES_GERADO_MIN = 16;
+export 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 const TETO_LEITURA_BYTES = 64 * 1024;
+/**
+ * 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 const CHAVES_INJETADAS_PELO_CORE = [
+    'PORT',
+    'NODE_ENV',
+    'HOME',
+    'NODE_OPTIONS',
+    'NEETRU_ENV',
+    'NEETRU_SDK_CLIENT_SECRET',
+    'NEETRU_CLIENT_ID',
+    'NEETRU_CLIENT_SECRET',
+    'NEETRU_OIDC_CLIENT_ID',
+    'NEETRU_OIDC_CLIENT_SECRET',
+    'NEETRU_OAUTH_CLIENT_ID',
+    'NEETRU_OAUTH_CLIENT_SECRET',
+    'NEETRU_API_KEY',
+];
+/** Famílias inteiras entregues por um canal do Core (hoje: módulos). Espelho de `CORE_INJECTED_ENV_PREFIXES`. */
+export const PREFIXOS_INJETADOS_PELO_CORE = ['NEETRU_MODULE_'];
+/**
+ * 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 const CHAVES_DO_CARREGADOR = [
+    'LD_PRELOAD',
+    'LD_LIBRARY_PATH',
+    'LD_AUDIT',
+    'DYLD_INSERT_LIBRARIES',
+    'DYLD_LIBRARY_PATH',
+    'PATH',
+    'NODE_PATH',
+    'NODE_OPTIONS',
+];
+/** O Core já entrega esta variável ao app na VM (nome exato ou família)? */
+export function chaveInjetadaPeloCore(chave) {
+    return CHAVES_INJETADAS_PELO_CORE.includes(chave) || PREFIXOS_INJETADOS_PELO_CORE.some((p) => chave.startsWith(p));
+}
+/**
+ * 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 function problemaNaChaveReservada(chave) {
+    if (CHAVES_DO_CARREGADOR.includes(chave)) {
+        return (`A chave ${chave} é reservada: ela muda como o processo carrega código (bibliotecas, ` +
+            'caminhos, opções do Node) e não pode vir de um segredo do produto. Escolha outro nome.');
+    }
+    if (CHAVES_INJETADAS_PELO_CORE.includes(chave)) {
+        return (`A chave ${chave} é reservada: o Core já a entrega ao app na VM por outro canal ` +
+            '(credencial SDK, OIDC ou CLI, ambiente ou unit do app). Não precisa registrá-la; ' +
+            'para um segredo seu, escolha outro nome.');
+    }
+    const prefixo = PREFIXOS_INJETADOS_PELO_CORE.find((p) => chave.startsWith(p));
+    if (prefixo) {
+        return (`Chaves que começam com ${prefixo} são reservadas: o Core já as entrega ao app na VM ` +
+            'quando o módulo está ativo. Não precisa registrá-las; para um segredo seu, escolha ' +
+            'outro nome.');
+    }
+    return 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 function problemaNaChave(chave) {
+    if (typeof chave === 'string' && CHAVE_SEGREDO_RE.test(chave))
+        return null;
+    if (typeof chave === 'string' && chave.includes('=')) {
+        return ('Parece que você passou CHAVE=VALOR. O valor do segredo nunca vai na linha de ' +
+            'comando (fica no histórico do shell). Passe só o nome e mande o valor por ' +
+            '--stdin, --from-file ou pelo pedido na tela. Se o valor já foi digitado, ' +
+            'considere-o exposto e troque-o.');
+    }
+    return ('Nome de segredo inválido. Use CAIXA_ALTA com letras, dígitos e underscore, ' +
+        'começando por letra, de 2 a 64 caracteres (ex.: NEETRU_WEBHOOK_SECRET). ' +
+        'O que foi digitado não é repetido aqui, caso seja o próprio valor.');
+}
+/**
+ * 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 function problemaNoValor(valor) {
+    if (valor.length === 0)
+        return 'O valor do segredo está vazio.';
+    if (Buffer.byteLength(valor, 'utf8') > TETO_VALOR_BYTES) {
+        return `O valor do segredo passa de ${TETO_VALOR_BYTES} bytes (teto do arquivo de ambiente na VM).`;
+    }
+    if (/[\r\n\0"'\\]/.test(valor) || valor !== valor.trim()) {
+        return ('O valor do segredo tem caractere que o arquivo de ambiente da VM não aceita ' +
+            '(quebra de linha, NUL, aspas, barra invertida, ou espaço ou caractere invisível ' +
+            'nas pontas, como a marca BOM de arquivo salvo em "UTF-8 com BOM"). Para chave ' +
+            'PEM ou JSON, grave em base64 e decodifique no app.');
+    }
+    return null;
+}
+/** Valida `--bytes` (só faz sentido com `--generate`). `null` se serve. */
+export function problemaNosBytes(bytes) {
+    if (!Number.isInteger(bytes) || bytes < BYTES_GERADO_MIN || bytes > BYTES_GERADO_MAX) {
+        return `--bytes deve ser um número inteiro de ${BYTES_GERADO_MIN} a ${BYTES_GERADO_MAX}.`;
+    }
+    return 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 function semQuebraFinal(texto) {
+    if (texto.endsWith('\r\n'))
+        return texto.slice(0, -2);
+    if (texto.endsWith('\n'))
+        return texto.slice(0, -1);
+    return texto;
+}
+/**
+ * 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 function problemaNoTextoDoTerminal(texto) {
+    if (!texto.includes(CARACTERE_DE_TROCA))
+        return null;
+    return ('O terminal mandou um caractere que não está em UTF-8, e ele foi trocado por um caractere de ' +
+        'substituição: o segredo gravado seria diferente do digitado. Ajuste o terminal para UTF-8 ' +
+        '(ex.: LANG=pt_BR.UTF-8), ou grave o valor num arquivo UTF-8 e use --from-file. ' +
+        'O conteúdo não é repetido aqui. Nada foi enviado.');
+}
+/** Nunca repete o caminho: o engano provável é colar o VALOR no lugar dele. */
+const CAMINHO_NAO_REPETIDO = '(o caminho não é repetido aqui, caso seja o próprio valor)';
+function mensagemDeLeitura(err) {
+    const codigo = err?.code;
+    if (codigo === 'ENOENT')
+        return `Arquivo não encontrado ${CAMINHO_NAO_REPETIDO}.`;
+    if (codigo === 'EISDIR')
+        return `O caminho é uma pasta, não um arquivo ${CAMINHO_NAO_REPETIDO}.`;
+    return `Não consegui ler o arquivo (${codigo ?? 'erro desconhecido'}) ${CAMINHO_NAO_REPETIDO}.`;
+}
+/**
+ * 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 async function lerValorDeArquivo(caminho, abrir = (c) => open(c, 'r')) {
+    const bruto = Buffer.alloc(TETO_LEITURA_BYTES + 1);
+    let lidos = 0;
+    let arquivo;
+    try {
+        arquivo = await abrir(caminho);
+        while (lidos < bruto.length) {
+            const { bytesRead } = await arquivo.read(bruto, lidos, bruto.length - lidos, null);
+            if (bytesRead === 0)
+                break;
+            lidos += bytesRead;
+        }
+    }
+    catch (err) {
+        throw new Error(mensagemDeLeitura(err));
+    }
+    finally {
+        await arquivo?.close().catch(() => undefined);
+    }
+    if (lidos > TETO_LEITURA_BYTES) {
+        throw new Error(`O arquivo passa de ${TETO_LEITURA_BYTES} bytes — não parece um segredo.`);
+    }
+    return semQuebraFinal(semBomInicial(decodificarUtf8(bruto.subarray(0, lidos), 'arquivo')));
+}
+/** Lê o valor inteiro de um fluxo (a entrada padrão, no `--stdin`). */
+export async function lerValorDeFluxo(fluxo) {
+    const partes = [];
+    let total = 0;
+    for await (const pedaco of fluxo) {
+        // Pedaço em texto = alguém já decodificou o fluxo (`setEncoding`), e o
+        // U+FFFD é o único rastro de byte trocado. Os pedaços em bytes são
+        // conferidos JUNTOS no fim: uma letra acentuada pode vir partida em dois.
+        // Revisão do #81 (M-r3-1): o U+FFFD que chega em bytes (EF BF BD, a
+        // conversão com perda feita antes da CLI) também é recusado, lá no fim,
+        // por `decodificarUtf8` — a regra não depende mais do formato do pedaço.
+        if (typeof pedaco === 'string' && pedaco.includes(CARACTERE_DE_TROCA))
+            throw recusaNaoUtf8('entrada');
+        const buf = typeof pedaco === 'string' ? Buffer.from(pedaco, 'utf8') : pedaco;
+        total += buf.length;
+        if (total > TETO_LEITURA_BYTES) {
+            throw new Error(`A entrada passa de ${TETO_LEITURA_BYTES} bytes — não parece um segredo.`);
+        }
+        partes.push(buf);
+    }
+    return semQuebraFinal(semBomInicial(decodificarUtf8(Buffer.concat(partes), 'entrada')));
+}
+/** Pedido cancelado (Ctrl+C ou fim da entrada antes da resposta). */
+export class PedidoCancelado extends Error {
+    constructor() {
+        super('Pedido cancelado — nada foi enviado.');
+        this.name = 'PedidoCancelado';
+    }
+}
+/**
+ * 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 function perguntarSemEco(perguntas, fluxos) {
+    const mudo = new Writable({
+        write(_pedaco, _codificacao, pronto) {
+            pronto();
+        },
+    });
+    const rl = createInterface({ input: fluxos.entrada, output: mudo, terminal: true });
+    const respostas = [];
+    return new Promise((resolve, reject) => {
+        let terminado = false;
+        const encerrar = (erro) => {
+            if (terminado)
+                return;
+            terminado = true;
+            rl.close();
+            if (erro)
+                reject(erro);
+            else
+                resolve(respostas);
+        };
+        // Ctrl+C em modo cru não vira sinal: chega aqui. Sem este ouvinte o
+        // readline só pausa, e o comando ficaria pendurado.
+        rl.on('SIGINT', () => {
+            fluxos.saida.write('\n');
+            encerrar(new PedidoCancelado());
+        });
+        rl.on('close', () => encerrar(new PedidoCancelado()));
+        const proxima = (i) => {
+            if (i >= perguntas.length) {
+                encerrar();
+                return;
+            }
+            fluxos.saida.write(`  ${perguntas[i]} `);
+            rl.question('', (resposta) => {
+                // O Enter também não foi ecoado: a quebra de linha é nossa.
+                fluxos.saida.write('\n');
+                respostas.push(resposta);
+                proxima(i + 1);
+            });
+        };
+        proxima(0);
+    });
+}
+//# sourceMappingURL=segredo-produto.js.map

package/dist/lib/texto-utf8.d.ts

@@ -0,0 +1,96 @@
+/**
+ * O texto não está em UTF-8 (ou traz U+FFFD) — recusa com o código
+ * `invalid_encoding`. A mensagem diz como salvar o arquivo, nunca o que ele
+ * contém.
+ */
+export declare class CodificacaoInvalida extends Error {
+    constructor(mensagem: string);
+}
+/** U+FFFD: o caractere que um decodificador UTF-8 põe no lugar de byte que não é UTF-8. */
+export declare const CARACTERE_DE_TROCA = "\uFFFD";
+/**
+ * De onde vieram os bytes (só muda o texto da recusa): `arquivo` e `entrada`
+ * são o `--from-file` e o `--stdin` do segredo; `env-file` é o `--env-file`
+ * do deploy e do build.
+ */
+export type OrigemDosBytes = 'arquivo' | 'entrada' | 'env-file';
+/**
+ * Tira UMA marca BOM (U+FEFF) do começo — a que o Bloco de Notas ("UTF-8 com
+ * BOM") e o `Set-Content -Encoding utf8` do Windows PowerShell 5.1 gravam no
+ * arquivo (medido: `ef bb bf …`). O PowerShell 7 grava sem a marca. Revisão do
+ * #81 (B3): sem isto o `trim()` de `problemaNoValor` via a marca como espaço
+ * e recusava com "espaço nas pontas", sem espaço nenhum à vista. Só uma, pelo
+ * mesmo motivo de `semQuebraFinal`.
+ */
+export declare function semBomInicial(texto: string): string;
+/**
+ * Como converter um arquivo ANSI para UTF-8 — uma receita por versão do
+ * PowerShell, porque o `Get-Content` lê diferente nas duas.
+ *
+ * Revisão do #81 (M-r3-1): a receita era só a do 5.1. No Windows PowerShell
+ * 5.1, o `Get-Content` lê arquivo sem marca em ANSI, e o `Set-Content
+ * -Encoding utf8` grava UTF-8 COM a marca BOM (`semBomInicial` a tira). No
+ * PowerShell 7, o `Get-Content` lê arquivo sem marca em UTF-8 (o padrão é
+ * `utf8NoBOM`): o "é" do ANSI vira U+FFFD antes de chegar à CLI, e o
+ * `Set-Content -Encoding utf8` (no 7, sem BOM) grava esse U+FFFD em UTF-8
+ * válido. Lá a leitura certa é `-Encoding ansi` (página ANSI da cultura,
+ * existe a partir do 7.4, segundo a documentação do `Get-Content`). No 5.1,
+ * `-Encoding ansi` dá erro de parâmetro e não cria o arquivo novo (medido), e
+ * a receita do 5.1 rodada no 7 grava U+FFFD — que `decodificarUtf8` recusa.
+ * Assim, a receita da versão errada nunca passa calada.
+ */
+export declare const COMO_CONVERTER_ANSI: string;
+/**
+ * UTF-16 tem marca (FF FE / FE FF), e a marca vence o `-Encoding` na leitura
+ * (medido no 5.1: o arquivo do `>` lido com `-Encoding UTF8` sai certo). Por
+ * isso a mesma receita serve nas duas versões.
+ */
+export declare const COMO_CONVERTER_UTF16: string;
+/** Exportada para o `--stdin` que já chega decodificado (`setEncoding`). */
+export declare function recusaNaoUtf8(origem: OrigemDosBytes): CodificacaoInvalida;
+/**
+ * O que impede estes bytes de serem lidos como o arquivo de origem — ou `null`
+ * quando são UTF-8 limpo:
+ *
+ *   1. `utf16`: marca UTF-16 (FF FE / FE FF) — antes caía em recusa que
+ *      citava "UTF-8 com BOM" (segredo) ou virava chave com NUL (env-file);
+ *   2. `nao-utf8`: bytes que não são UTF-8 (`isUtf8`) — o ANSI do 5.1;
+ *   3. `troca-gravada`: U+FFFD em UTF-8 válido (revisão do #81, M-r3-1) — a
+ *      conversão com perda feita antes da CLI. Limite declarado: um U+FFFD
+ *      gravado de propósito cai aqui também (não dá para distinguir).
+ *
+ * A marca BOM do UTF-8 (EF BB BF) é UTF-8 válido: não é problema.
+ *
+ * Fonte única da regra: `decodificarUtf8` recusa por ela, e o `env switch` e a
+ * varredura de segredo público decidem por ela (rodada final 2 do #81).
+ */
+export type ProblemaDeCodificacao = 'utf16' | 'nao-utf8' | 'troca-gravada';
+export declare function problemaDeCodificacao(bruto: Buffer): ProblemaDeCodificacao | null;
+/**
+ * Converte os bytes lidos em texto, RECUSANDO o que não é o arquivo de origem
+ * (os três casos de `problemaDeCodificacao`). No U+FFFD, a CLI fica mais
+ * estrita que o Core.
+ *
+ * A marca BOM do UTF-8 (EF BB BF) passa daqui, e quem chama a tira com
+ * `semBomInicial`.
+ */
+export declare function decodificarUtf8(bruto: Buffer, origem: OrigemDosBytes): string;
+/**
+ * `neetru env switch` (rodada final 2 do #81, achado BAIXA): o comando lia o
+ * `.env.local` com `readFile(…, 'utf-8')` e REGRAVAVA o arquivo inteiro. Medido
+ * no processo real: um `.env.local` ANSI com `NOME_LOJA=Café` terminava com
+ * `ef bf bd` no lugar do `e9`, e um UTF-16 virava texto ilegível — exit 0 e
+ * "✓" nos dois. Agora ele recusa ANTES de gravar e não toca no arquivo.
+ *
+ * Recusa só o que a regravação estragaria (`utf16` e `nao-utf8`). Um U+FFFD
+ * que já está no arquivo (`troca-gravada`) sai byte a byte igual — o comando
+ * não perde nada ali, então segue.
+ */
+export declare function recusaDoEnvSwitch(arquivo: string, problema: 'utf16' | 'nao-utf8'): CodificacaoInvalida;
+/**
+ * Varredura de segredo público do `neetru deploy` (rodada final 2 do #81): um
+ * `.env*` que o bundler lê não está em UTF-8 limpo. A varredura segue — ela
+ * confere o valor como o bundler o lê —, mas o app vai receber outro valor, e
+ * isso não passa calado. Nunca repete o conteúdo.
+ */
+export declare function avisoEnvDoBundlerForaDeUtf8(arquivo: string, problema: ProblemaDeCodificacao): string;