@neetru/cli 2.29.0 → 2.32.0

package/dist/commands/secrets.d.ts

@@ -0,0 +1,91 @@
+/**
+ * `neetru secrets` — segredos PRÓPRIOS do produto (bug_8b85353b, Parte 3 de 3).
+ *
+ * Subcomandos:
+ *   neetru secrets set <CHAVE> --env <ambiente> [--generate | --from-file <caminho> | --stdin]
+ *   neetru secrets list [--env <ambiente>] [--include-archived]
+ *   neetru secrets archive <CHAVE> --env <ambiente>
+ *
+ * Contrato Core (core#632, `src/app/api/cli/v1/products/[slug]/secrets/route.ts`):
+ *   GET    /api/cli/v1/products/{slug}/secrets?environmentId=&includeArchived=
+ *          — NOMES e metadado, nunca valores. Roles admin|operator|viewer.
+ *   POST   /api/cli/v1/products/{slug}/secrets  { environmentId, key, value }
+ *                                              | { environmentId, key, generate: true, bytes? }
+ *          — cria ou troca o valor. Roles admin|operator. `prod` exige step-up MFA.
+ *   DELETE /api/cli/v1/products/{slug}/secrets?environmentId=&key=
+ *          — arquiva (soft delete). Roles admin|operator. `prod` exige step-up MFA.
+ *
+ * Por que existe: o Core recusa segredo em `envVars` do deploy VM (o documento
+ * do deploy é lido por toda a equipe no Firestore), e até aqui a CLI não tinha
+ * caminho nenhum para o segredo do PRÓPRIO produto — `neetru env set` é só
+ * Cloud Run. O valor sai daqui direto para o Secret Manager, por TLS, e não
+ * fica em lugar nenhum: nem no Firestore, nem no log, nem na saída desta CLI.
+ *
+ * O VALOR nunca vem do argv (ver `src/lib/segredo-produto.ts`). O grupo e os
+ * três subcomandos aceitam argumentos desconhecidos de propósito —
+ * `allowUnknownOption` — para RECUSAR com mensagem própria um `--value=...` ou
+ * um valor colado onde não devia: o erro padrão do commander ("unknown option
+ * '--value=sk_live…'", "unknown command 'sk_live…'") imprimiria o segredo de
+ * volta no terminal.
+ *
+ * ATENÇÃO (2026-10-16): a entrega ao app na VM depende do lado do AGENTE
+ * (Parte 2 de bug_8b85353b, `neetru-agent-service-vm`), que ainda não foi
+ * liberado. Até lá o registro funciona mas o segredo não chega ao app — e a
+ * CLI diz isso ao gravar, em vez de deixar o dev descobrir em produção.
+ */
+import type { Command } from 'commander';
+import { type StepUpOptions } from '../lib/cli-write.js';
+import { type TenantEnvironmentId } from '../lib/envs.js';
+import { type FluxosDoPedido } from '../lib/segredo-produto.js';
+type Origem = 'generated' | 'provided';
+type Situacao = 'active' | 'arquivado';
+/** Linha de `GET …/secrets`. O Core nunca manda valor — e só estes campos saem daqui. */
+export interface SegredoListado {
+    key: string;
+    environmentId: TenantEnvironmentId;
+    origin: Origem;
+    status: Situacao;
+    revision: number;
+    createdAt: string;
+    updatedAt: string;
+    updatedBy: string;
+}
+/** Dependências de entrada — trocáveis no teste; em produção, o terminal. */
+export interface EntradaDoValor extends FluxosDoPedido {
+    /** A entrada é um terminal interativo? (pode perguntar o valor na tela) */
+    interativo: boolean;
+}
+/**
+ * Só os campos públicos de uma linha. O Core já passa por `toPublicProductSecret`;
+ * filtrar de novo aqui é para um campo novo do servidor nunca chegar à tela
+ * sem alguém decidir que ele pode.
+ */
+export declare function linhaPublica(s: SegredoListado): SegredoListado;
+export interface SecretsSetOptions extends StepUpOptions {
+    key?: string;
+    product?: string;
+    env?: string;
+    generate?: boolean;
+    /** Texto cru do `--bytes` (validado aqui). */
+    bytes?: string;
+    fromFile?: string;
+    stdin?: boolean;
+    /** Argumentos que sobraram depois do nome — sempre recusados. */
+    extras?: string[];
+}
+export declare function runSecretsSet(opts: SecretsSetOptions, entrada?: EntradaDoValor): Promise<void>;
+export interface SecretsListOptions {
+    product?: string;
+    env?: string;
+    includeArchived?: boolean;
+    json?: boolean;
+}
+export declare function runSecretsList(opts: SecretsListOptions): Promise<void>;
+export interface SecretsArchiveOptions extends StepUpOptions {
+    key?: string;
+    product?: string;
+    env?: string;
+}
+export declare function runSecretsArchive(opts: SecretsArchiveOptions): Promise<void>;
+export declare function registerSecretsCommand(program: Command): void;
+export {};

package/dist/commands/secrets.js

@@ -0,0 +1,471 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { apiRequest } from '../lib/api-client.js';
+import { renderTable, fmtTimestamp } from '../lib/render.js';
+import { requireToken, handleApiError, confirmDestructive, printWriteResult, resolveStepUp, isMfaRequiredError, } from '../lib/cli-write.js';
+import { loadProductConfig } from '../lib/product-config.js';
+import { listarAmbientesTenant, resolverAmbienteTenant, } from '../lib/envs.js';
+import { AVISO_AGENTE_PENDENTE, CodificacaoInvalida, PedidoCancelado, lerValorDeArquivo, lerValorDeFluxo, perguntarSemEco, problemaNaChave, problemaNaChaveReservada, problemaNoTextoDoTerminal, problemaNoValor, problemaNosBytes, } from '../lib/segredo-produto.js';
+import { log } from '../utils/logger.js';
+import { safeExit } from '../utils/safe-exit.js';
+function entradaPadrao() {
+    return { entrada: process.stdin, saida: process.stderr, interativo: !!process.stdin.isTTY };
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function falhar(json, codigo, mensagem) {
+    if (json)
+        console.log(JSON.stringify({ ok: false, error: codigo, message: mensagem }));
+    else
+        log.error(mensagem);
+    return safeExit(1);
+}
+/**
+ * Só os campos públicos de uma linha. O Core já passa por `toPublicProductSecret`;
+ * filtrar de novo aqui é para um campo novo do servidor nunca chegar à tela
+ * sem alguém decidir que ele pode.
+ */
+export function linhaPublica(s) {
+    return {
+        key: s.key,
+        environmentId: s.environmentId,
+        origin: s.origin,
+        status: s.status,
+        revision: s.revision,
+        createdAt: s.createdAt,
+        updatedAt: s.updatedAt,
+        updatedBy: s.updatedBy,
+    };
+}
+function textoOrigem(o) {
+    return o === 'generated' ? 'sorteado pelo Core' : 'informado';
+}
+function textoSituacao(s) {
+    return s === 'active' ? chalk.green('ativo') : chalk.dim('arquivado');
+}
+async function resolverProduto(product, json) {
+    const explicito = product?.trim();
+    if (explicito)
+        return explicito;
+    const cfg = await loadProductConfig();
+    if (cfg?.slug)
+        return cfg.slug;
+    return falhar(json, 'product_required', 'Não sei de qual produto é o segredo: passe --product <slug> ou rode o comando na pasta ' +
+        'do produto (com neetru.config.json).');
+}
+function exigirAmbiente(env, json) {
+    if (!env?.trim()) {
+        return falhar(json, 'environment_required', `--env é obrigatório (${listarAmbientesTenant()}). Segredo no ambiente errado não dá ` +
+            'erro: o app só não o encontra — por isso não há ambiente padrão aqui.');
+    }
+    return resolverAmbienteTenant(env, json);
+}
+function exigirChave(chave, json) {
+    const problema = problemaNaChave(chave);
+    if (problema)
+        return falhar(json, 'invalid_key', problema);
+    return chave;
+}
+/**
+ * Chave que o Core reserva (ele mesmo já a entrega ao app) — recusada ANTES
+ * de pedir o valor. Revisão do #81 (M1): antes a CLI pedia, mandava, e só o
+ * Core recusava. O `archive` não passa por aqui: só o formato, como no Core.
+ */
+function exigirChaveRegistravel(chave, json) {
+    const problema = problemaNaChaveReservada(chave);
+    if (problema)
+        falhar(json, 'reserved_key', problema);
+}
+/**
+ * Recusa argumento ou opção que o subcomando não conhece — sem repeti-lo. O
+ * erro padrão do commander ("unknown option '--value=sk_live…'", "unknown
+ * command 'sk_live…'") imprimiria o segredo de volta. Revisão do #81 (B2):
+ * vale também para o grupo (`secrets --value=… set`), `list` e `archive`.
+ */
+function recusarArgumentoDesconhecido(json) {
+    return falhar(json, 'unknown_argument', 'Argumento não reconhecido. O que foi digitado não é repetido aqui, caso seja um segredo; ' +
+        'se for, considere-o exposto e troque-o. Veja `neetru secrets <subcomando> --help`.');
+}
+/** Recusa argumento que sobrou na linha de comando — sem repeti-lo. */
+function recusarArgumentosExtras(extras, json) {
+    if (!extras || extras.length === 0)
+        return;
+    falhar(json, 'value_in_argv', 'Argumento não reconhecido depois do nome do segredo. O valor nunca vai na linha de ' +
+        'comando (fica no histórico do shell e aparece para outros processos). Use --stdin, ' +
+        '--from-file <caminho> ou deixe a CLI perguntar o valor na tela; se o Core puder ' +
+        'sortear o valor, use --generate. Se você digitou o valor aí, considere-o exposto e ' +
+        'troque-o. (O que foi digitado não é repetido aqui.)');
+}
+/**
+ * Lê o valor pela porta escolhida. `null` = `--generate` (o Core sorteia).
+ * Nunca imprime o valor, nem em erro.
+ *
+ * Nenhuma recusa (`falhar` → `safeExit`) fica DENTRO do `try`: o `safeExit`
+ * para o fluxo lançando um sinal, e um `catch` em volta o reprocessaria como
+ * erro de leitura — saída dupla e mensagem errada.
+ */
+async function lerValor(opts, entrada) {
+    if (opts.generate)
+        return null;
+    if (opts.stdin && entrada.interativo) {
+        // `--stdin` sem pipe leria do próprio terminal — e o terminal mostraria
+        // cada tecla. Para digitar, o caminho é o pedido sem eco.
+        return falhar(opts.json, 'stdin_is_terminal', '--stdin espera o valor por um pipe (ex.: printf %s "$VALOR" | neetru secrets set ...). ' +
+            'Para digitar o valor, rode sem --stdin: a CLI pergunta e o que você digita não aparece.');
+    }
+    const perguntarNaTela = opts.fromFile === undefined && !opts.stdin;
+    if (perguntarNaTela && (opts.json || opts.nonInteractive || !entrada.interativo)) {
+        return falhar(opts.json, 'value_source_required', 'De onde vem o valor? Sem terminal interativo, use --stdin (ex.: ' +
+            'printf %s "$VALOR" | neetru secrets set CHAVE --env prod --stdin), ' +
+            '--from-file <caminho>, ou --generate para o Core sortear.');
+    }
+    let lido;
+    try {
+        if (opts.fromFile !== undefined)
+            lido = [await lerValorDeArquivo(opts.fromFile)];
+        else if (opts.stdin)
+            lido = [await lerValorDeFluxo(entrada.entrada)];
+        else
+            lido = await perguntarSemEco(['Valor do segredo (não aparece na tela):', 'Repita o valor:'], entrada);
+    }
+    catch (err) {
+        const codigo = err instanceof PedidoCancelado
+            ? 'cancelled'
+            : err instanceof CodificacaoInvalida
+                ? 'invalid_encoding'
+                : 'value_read_failed';
+        return falhar(opts.json, codigo, err instanceof Error ? err.message : String(err));
+    }
+    // Revisão do #81 (M-r2-1): o `readline` decodifica as teclas e troca byte
+    // que não é UTF-8 por U+FFFD, sem erro — o segredo gravado seria outro.
+    // Vem antes do "não batem": as duas respostas trocadas batem entre si.
+    const problemaNaTela = perguntarNaTela ? lido.map(problemaNoTextoDoTerminal).find((p) => p !== null) : undefined;
+    if (problemaNaTela)
+        return falhar(opts.json, 'invalid_encoding', problemaNaTela);
+    if (perguntarNaTela && lido[0] !== lido[1]) {
+        return falhar(opts.json, 'value_mismatch', 'Os dois valores digitados não batem. Nada foi enviado.');
+    }
+    const valor = lido[0];
+    const problema = problemaNoValor(valor);
+    if (problema)
+        return falhar(opts.json, 'invalid_value', `${problema} Nada foi enviado.`);
+    return valor;
+}
+/**
+ * Step-up MFA do Core para ESCRITA em produção (dev-local/staging só pedem o
+ * papel admin|operator). Resolve ANTES do primeiro envio — a ordem é
+ * `--mfa-token` → sessão de 1h → pergunta do TOTP — para o pedido com o
+ * valor não ir ao Core só para voltar 401.
+ */
+async function cabecalhosDeProducao(ambiente, opts, skipSession = false) {
+    if (ambiente !== 'prod')
+        return {};
+    const { headers } = await resolveStepUp({ ...opts, dryRun: false, skipSession });
+    return headers;
+}
+/** O Core recusou a sessão de 1h e ainda dá para pedir um TOTP fresco? */
+function cabeRepetirComTotp(ambiente, headers, erro) {
+    return ambiente === 'prod' && isMfaRequiredError(erro) && !headers['X-Neetru-MFA-Token'];
+}
+export async function runSecretsSet(opts, entrada = entradaPadrao()) {
+    recusarArgumentosExtras(opts.extras, opts.json);
+    const chave = exigirChave(opts.key, opts.json);
+    exigirChaveRegistravel(chave, opts.json);
+    const ambiente = exigirAmbiente(opts.env, opts.json);
+    const origens = [!!opts.generate, opts.fromFile !== undefined, !!opts.stdin].filter(Boolean).length;
+    if (origens > 1) {
+        falhar(opts.json, 'value_source_conflict', 'Escolha UMA origem do valor: --generate, --from-file ou --stdin.');
+    }
+    let bytes;
+    if (opts.bytes !== undefined) {
+        if (!opts.generate) {
+            falhar(opts.json, 'invalid_input', '--bytes só vale com --generate (é o tamanho do valor sorteado).');
+        }
+        bytes = Number(opts.bytes);
+        const problema = problemaNosBytes(bytes);
+        if (problema)
+            falhar(opts.json, 'invalid_input', problema);
+    }
+    const slug = await resolverProduto(opts.product, opts.json);
+    // Login ANTES do valor (revisão do #81): sem sessão, o dev não digita o
+    // segredo duas vezes só para ler "Nenhuma sessão ativa".
+    const token = await requireToken(opts.json);
+    const valor = await lerValor(opts, entrada);
+    const body = valor === null
+        ? { environmentId: ambiente, key: chave, generate: true, ...(bytes !== undefined ? { bytes } : {}) }
+        : { environmentId: ambiente, key: chave, value: valor };
+    let headers = await cabecalhosDeProducao(ambiente, opts);
+    const spinner = opts.json
+        ? null
+        : ora({ text: `Gravando ${chave} (${ambiente}) no Secret Manager…`, color: 'blue' }).start();
+    let res = null;
+    let falha = null;
+    try {
+        res = await apiRequest(`/api/cli/v1/products/${encodeURIComponent(slug)}/secrets`, {
+            method: 'POST',
+            token,
+            headers,
+            body,
+        });
+    }
+    catch (erro) {
+        falha = erro;
+    }
+    if (res === null && cabeRepetirComTotp(ambiente, headers, falha)) {
+        // A sessão de 1h salva foi recusada pelo Core: pede um TOTP fresco, uma vez.
+        // FORA de qualquer `try`: o fail-closed do `resolveStepUp` (safeExit) não
+        // pode ser reprocessado como erro de API (mesma regra do `withStepUpRetry`).
+        spinner?.stop();
+        headers = await cabecalhosDeProducao(ambiente, opts, true);
+        try {
+            res = await apiRequest(`/api/cli/v1/products/${encodeURIComponent(slug)}/secrets`, {
+                method: 'POST',
+                token,
+                headers,
+                body,
+            });
+        }
+        catch (erro) {
+            falha = erro;
+        }
+    }
+    if (res === null) {
+        spinner?.fail('O Core não gravou o segredo.');
+        return handleApiError(falha, opts.json);
+    }
+    spinner?.stop();
+    const gerado = res.origin === 'generated';
+    const acao = res.created ? 'registrado' : 'trocado';
+    printWriteResult({
+        product: slug,
+        key: res.key,
+        environmentId: res.environmentId,
+        origin: res.origin,
+        revision: res.revision,
+        created: res.created,
+        secretRef: res.secretRef,
+        note: AVISO_AGENTE_PENDENTE,
+    }, `Segredo ${chalk.bold(res.key)} ${acao} em ${res.environmentId} (revisão ${res.revision})` +
+        (gerado ? ' — o Core sorteou o valor; ninguém o vê, nem você.' : '.'), opts.json);
+    if (opts.json)
+        return;
+    if (!res.created)
+        log.dim('O valor anterior deixa de ser entregue a partir do próximo deploy.');
+    log.dim(`Nome no Secret Manager: ${res.secretRef} (é o nome, não o valor).`);
+    log.dim(`Para o app receber: faça um novo deploy em ${res.environmentId}.`);
+    log.warn(AVISO_AGENTE_PENDENTE);
+}
+export async function runSecretsList(opts) {
+    const ambiente = opts.env?.trim() ? resolverAmbienteTenant(opts.env, opts.json) : undefined;
+    const slug = await resolverProduto(opts.product, opts.json);
+    const token = await requireToken(opts.json);
+    const qs = new URLSearchParams();
+    if (ambiente)
+        qs.set('environmentId', ambiente);
+    if (opts.includeArchived)
+        qs.set('includeArchived', 'true');
+    const sufixo = qs.toString() ? `?${qs.toString()}` : '';
+    const spinner = opts.json ? null : ora({ text: `Buscando segredos de ${slug}…`, color: 'blue' }).start();
+    let res;
+    try {
+        res = await apiRequest(`/api/cli/v1/products/${encodeURIComponent(slug)}/secrets${sufixo}`, {
+            token,
+        });
+        spinner?.stop();
+    }
+    catch (erro) {
+        spinner?.fail('Não consegui listar os segredos.');
+        handleApiError(erro, opts.json);
+    }
+    const linhas = (res.secrets ?? []).map(linhaPublica);
+    if (opts.json) {
+        console.log(JSON.stringify({ ok: true, productId: res.productId, slug: res.slug, count: linhas.length, secrets: linhas }));
+        return;
+    }
+    log.heading(`Segredos de ${chalk.bold(res.slug ?? slug)}${ambiente ? ` — ${ambiente}` : ''} (${linhas.length})`);
+    log.dim('Só nomes e dados de controle: o valor nunca sai do Secret Manager.');
+    if (linhas.length === 0) {
+        log.dim('Nenhum segredo registrado.');
+        log.dim('Para registrar: neetru secrets set CHAVE --env <ambiente> [--generate]');
+        return;
+    }
+    renderTable([
+        { header: 'Chave', value: (r) => r.key, identificador: true },
+        { header: 'Ambiente', value: (r) => r.environmentId, identificador: true },
+        { header: 'Origem', value: (r) => textoOrigem(r.origin), maxWidth: 20 },
+        { header: 'Situação', value: (r) => textoSituacao(r.status), maxWidth: 12 },
+        { header: 'Revisão', value: (r) => String(r.revision), maxWidth: 8 },
+        { header: 'Atualizado em', value: (r) => fmtTimestamp(r.updatedAt), maxWidth: 20 },
+        { header: 'Por', value: (r) => r.updatedBy, maxWidth: 32 },
+    ], linhas);
+}
+export async function runSecretsArchive(opts) {
+    // Só o formato: uma chave que virou reservada depois de registrada precisa
+    // poder ser arquivada (mesma regra do Core em `_archiveProductSecretCore`).
+    const chave = exigirChave(opts.key, opts.json);
+    const ambiente = exigirAmbiente(opts.env, opts.json);
+    const slug = await resolverProduto(opts.product, opts.json);
+    const token = await requireToken(opts.json);
+    await confirmDestructive(`Arquivar o segredo ${chave} de ${slug} em ${ambiente}? O app deixa de recebê-lo a partir ` +
+        'do próximo deploy (a versão no Secret Manager fica guardada para rollback).', opts);
+    const qs = new URLSearchParams({ environmentId: ambiente, key: chave }).toString();
+    let headers = await cabecalhosDeProducao(ambiente, opts);
+    const spinner = opts.json ? null : ora({ text: `Arquivando ${chave} (${ambiente})…`, color: 'blue' }).start();
+    let res = null;
+    let falha = null;
+    try {
+        res = await apiRequest(`/api/cli/v1/products/${encodeURIComponent(slug)}/secrets?${qs}`, {
+            method: 'DELETE',
+            token,
+            headers,
+        });
+    }
+    catch (erro) {
+        falha = erro;
+    }
+    if (res === null && cabeRepetirComTotp(ambiente, headers, falha)) {
+        // Sessão de 1h recusada: TOTP fresco, uma vez, FORA de qualquer `try`.
+        spinner?.stop();
+        headers = await cabecalhosDeProducao(ambiente, opts, true);
+        try {
+            res = await apiRequest(`/api/cli/v1/products/${encodeURIComponent(slug)}/secrets?${qs}`, {
+                method: 'DELETE',
+                token,
+                headers,
+            });
+        }
+        catch (erro) {
+            falha = erro;
+        }
+    }
+    if (res === null) {
+        spinner?.fail('O Core não arquivou o segredo.');
+        return handleApiError(falha, opts.json);
+    }
+    spinner?.stop();
+    printWriteResult({ product: slug, key: res.key, environmentId: res.environmentId, archived: res.archived }, res.archived
+        ? `Segredo ${chalk.bold(res.key)} arquivado em ${res.environmentId}. Faça um novo deploy para o app deixar de recebê-lo.`
+        : `Segredo ${chalk.bold(res.key)} já estava arquivado em ${res.environmentId} — nada mudou.`, opts.json);
+}
+// ---------------------------------------------------------------------------
+// Registro no commander
+// ---------------------------------------------------------------------------
+const AJUDA_SET = `
+O valor NUNCA vai na linha de comando (fica no histórico do shell). Ele entra por:
+  --stdin               printf %s "$VALOR" | neetru secrets set CHAVE --env prod --stdin
+  --from-file <caminho> neetru secrets set CHAVE --env prod --from-file ./valor.txt
+  pergunta na tela      neetru secrets set CHAVE --env staging   (o que você digita não aparece)
+Ou o Core sorteia, e ninguém vê o valor:
+  --generate            neetru secrets set NEETRU_WEBHOOK_SECRET --env prod --generate
+
+O valor é lido em UTF-8 (com ou sem a marca BOM); arquivo em ANSI ou UTF-16 é recusado,
+e também o que traz o caractere de substituição (U+FFFD), rastro de conversão que perdeu letra.
+Para converter um arquivo ANSI em UTF-8:
+  Windows PowerShell 5.1   Get-Content <arquivo> | Set-Content -Encoding utf8 <arquivo-novo>
+  PowerShell 7.4 ou mais   Get-Content -Encoding ansi <arquivo> | Set-Content -Encoding utf8 <arquivo-novo>
+No Windows PowerShell 5.1, o pipe troca letra acentuada por "?" antes de chegar aqui, e a
+CLI não tem como perceber: para valor com acento, use --from-file com arquivo em UTF-8.
+
+Produção (--env prod) pede o código MFA: --mfa-token <código> ou \`neetru auth mfa-session\`.
+`;
+export function registerSecretsCommand(program) {
+    const secretsCmd = program
+        .command('secrets')
+        .description('Gerenciar segredos do próprio produto (o valor vai direto pro Secret Manager)')
+        // Revisão do #81 (B2): opção desconhecida ANTES do subcomando
+        // (`secrets --value=… set`) ou o valor no lugar do subcomando caíam no erro
+        // padrão do commander, que repete o argumento. Sem argumento nenhum, segue
+        // a ajuda, como antes. O `helpCommand(true)` é necessário porque, com
+        // `.action` no grupo, o commander desliga o subcomando implícito `help`
+        // (`secrets help set` passaria a ser recusado).
+        .helpCommand(true)
+        .allowUnknownOption()
+        .allowExcessArguments()
+        .action((_opts, cmd) => {
+        if (cmd.args.length === 0)
+            cmd.help({ error: true });
+        recusarArgumentoDesconhecido();
+    });
+    secretsCmd
+        .command('set <chave>')
+        .description('Registrar um segredo do produto ou trocar o valor dele (o valor nunca vai na linha de comando)')
+        .option('--env <ambiente>', 'ambiente: dev-local | staging | prod (obrigatório)')
+        .option('--product <slug>', 'slug do produto (padrão: o do neetru.config.json da pasta)')
+        .option('--generate', 'o Core sorteia o valor e ninguém o vê, nem você')
+        .option('--bytes <n>', 'tamanho do valor sorteado, de 16 a 128 bytes (padrão 32); só com --generate')
+        .option('--from-file <caminho>', 'lê o valor de um arquivo (uma quebra de linha no fim é ignorada)')
+        .option('--stdin', 'lê o valor da entrada padrão (uma quebra de linha no fim é ignorada)')
+        .option('--mfa-token <código>', 'código TOTP, exigido em prod (ou use `neetru auth mfa-session`)')
+        .option('--non-interactive', 'nunca pergunta nada na tela (CI)')
+        .option('--json', 'saída em JSON')
+        // Para RECUSAR `--value=…` e valor colado depois do nome sem ecoá-los: o
+        // erro padrão do commander repetiria o argumento (e o segredo) na tela.
+        .allowUnknownOption()
+        .allowExcessArguments()
+        .addHelpText('after', AJUDA_SET)
+        .action(async (chave, opts, cmd) => {
+        await runSecretsSet({
+            key: chave,
+            extras: cmd.args.slice(1),
+            env: opts.env,
+            product: opts.product,
+            generate: !!opts.generate,
+            bytes: opts.bytes,
+            fromFile: opts.fromFile,
+            stdin: !!opts.stdin,
+            mfaToken: opts.mfaToken,
+            nonInteractive: !!opts.nonInteractive,
+            json: !!opts.json,
+        });
+    });
+    secretsCmd
+        .command('list')
+        .description('Listar os segredos do produto — só nomes e dados de controle, nunca o valor')
+        .option('--env <ambiente>', 'só um ambiente: dev-local | staging | prod')
+        .option('--product <slug>', 'slug do produto (padrão: o do neetru.config.json da pasta)')
+        .option('--include-archived', 'mostra também os arquivados')
+        .option('--json', 'saída em JSON')
+        // Recusa própria, sem repetir o argumento (ver o grupo acima).
+        .allowUnknownOption()
+        .allowExcessArguments()
+        .action(async (opts, cmd) => {
+        if (cmd.args.length > 0)
+            recusarArgumentoDesconhecido(!!opts.json);
+        await runSecretsList({
+            env: opts.env,
+            product: opts.product,
+            includeArchived: !!opts.includeArchived,
+            json: !!opts.json,
+        });
+    });
+    secretsCmd
+        .command('archive <chave>')
+        .description('Arquivar um segredo: o app deixa de recebê-lo a partir do próximo deploy')
+        .option('--env <ambiente>', 'ambiente: dev-local | staging | prod (obrigatório)')
+        .option('--product <slug>', 'slug do produto (padrão: o do neetru.config.json da pasta)')
+        .option('--yes', 'pula a confirmação (necessário em --json/CI)')
+        .option('--force', 'mesmo que --yes')
+        .option('--mfa-token <código>', 'código TOTP, exigido em prod (ou use `neetru auth mfa-session`)')
+        .option('--non-interactive', 'nunca pergunta nada na tela (CI)')
+        .option('--json', 'saída em JSON')
+        // Recusa própria, sem repetir o argumento (ver o grupo acima). Também não
+        // arquiva com argumento sobrando: o commander o ignoraria calado.
+        .allowUnknownOption()
+        .allowExcessArguments()
+        .action(async (chave, opts, cmd) => {
+        if (cmd.args.length > 1)
+            recusarArgumentoDesconhecido(!!opts.json);
+        await runSecretsArchive({
+            key: chave,
+            env: opts.env,
+            product: opts.product,
+            yes: !!opts.yes,
+            force: !!opts.force,
+            mfaToken: opts.mfaToken,
+            nonInteractive: !!opts.nonInteractive,
+            json: !!opts.json,
+        });
+    });
+}
+//# sourceMappingURL=secrets.js.map

package/dist/commands/servers.js

@@ -53,7 +53,7 @@ export async function runServersList(opts) {
     }
     log.heading(`Servers (${res.count})`);
     const columns = [
-        { header: 'ID', value: (r) => r.id, maxWidth: 22 },
+        { header: 'ID', value: (r) => r.id, identificador: true },
         { header: 'NOME', value: (r) => r.name ?? '—', maxWidth: 24 },
         { header: 'PROVIDER', value: (r) => r.provider ?? '—' },
         { header: 'REGIÃO', value: (r) => r.region ?? '—' },
@@ -100,7 +100,7 @@ export async function runServersFleetStatus(opts) {
         return chalk.green(`${pct}%`);
     };
     renderTable([
-        { header: 'ID', value: (r) => r.id, maxWidth: 22 },
+        { header: 'ID', value: (r) => r.id, identificador: true },
         { header: 'NOME', value: (r) => r.name ?? '—', maxWidth: 20 },
         { header: 'ROLE', value: (r) => r.role ?? 'multi' },
         { header: 'STATUS', value: (r) => r.status ?? '—' },
@@ -321,6 +321,7 @@ export async function runServersDeactivate(id, opts) {
     const token = await requireToken(opts.json);
     const serverId = await pickServer(token, {
         fromFlag: id,
+        inputs: ['<serverId>'],
         json: opts.json,
         message: 'Server a desativar:',
     });
@@ -428,6 +429,7 @@ export async function runServersDispatch(id, commandType, opts) {
     const token = await requireToken(opts.json);
     const serverId = await pickServer(token, {
         fromFlag: id,
+        inputs: ['<serverId>'],
         json: opts.json,
         message: 'Server alvo:',
     });
@@ -603,13 +605,13 @@ export async function runServersPgbouncerSyncUserlist(serverId, opts = {}) {
         log.success(`Userlist do PgBouncer sincronizado na VM ${resp.serverId} (mode ${resp.mode}).`);
     }
     renderTable([
-        { header: 'DB', value: (r) => r.dbId, maxWidth: 24 },
+        { header: 'DB', value: (r) => r.dbId, identificador: true },
         { header: 'PAPÉIS', value: (r) => r.roles.join(', '), maxWidth: 50 },
     ], plan.databases);
     if (plan.skipped.length > 0) {
         log.heading('Bancos deixados de fora (papel fora do formato)');
         renderTable([
-            { header: 'DB', value: (r) => r.dbId, maxWidth: 24 },
+            { header: 'DB', value: (r) => r.dbId, identificador: true },
             { header: 'MOTIVO', value: (r) => r.reason, maxWidth: 50 },
         ], plan.skipped);
     }

package/dist/commands/status.js

@@ -82,11 +82,11 @@ export async function runStatus(opts) {
     }
     console.log();
     console.log(chalk.bold('  Last Build'));
-    console.log(`  ${chalk.dim('  ID:')}              ${status.lastBuildId ? chalk.cyan(status.lastBuildId.slice(0, 12)) : chalk.dim('—')}`);
+    console.log(`  ${chalk.dim('  ID:')}              ${status.lastBuildId ? chalk.cyan(status.lastBuildId) : chalk.dim('—')}`);
     console.log(`  ${chalk.dim('  Status:')}          ${colorStatus(status.lastBuildStatus)}`);
     console.log();
     console.log(chalk.bold('  Last Deployment'));
-    console.log(`  ${chalk.dim('  ID:')}              ${status.lastDeploymentId ? chalk.cyan(status.lastDeploymentId.slice(0, 12)) : chalk.dim('—')}`);
+    console.log(`  ${chalk.dim('  ID:')}              ${status.lastDeploymentId ? chalk.cyan(status.lastDeploymentId) : chalk.dim('—')}`);
     console.log(`  ${chalk.dim('  Status:')}          ${colorStatus(status.lastDeploymentStatus)}`);
     if (status.expiresAt) {
         const expiresIn = Math.ceil((new Date(status.expiresAt).getTime() - Date.now()) / (1000 * 60 * 60 * 24));

package/dist/commands/support.js

@@ -66,13 +66,15 @@ export async function runSupportTicketsList(opts) {
         return;
     }
     renderTable([
-        { header: 'ID', value: (t) => t.id, maxWidth: 18 },
+        { header: 'ID', value: (t) => t.id, identificador: true },
         { header: 'TÍTULO', value: (t) => t.title ?? '—', maxWidth: 36 },
         { header: 'STATUS', value: (t) => colorStatus(t.status) },
         { header: 'SEVERITY', value: (t) => t.severity ?? '—' },
-        { header: 'PRODUTO', value: (t) => t.productId ?? '—', maxWidth: 18 },
+        { header: 'PRODUTO', value: (t) => t.productId ?? '—', identificador: true },
         { header: 'SLA', value: (t) => (t.slaBreached ? chalk.red('estourado') : 'ok') },
-        { header: 'ASSIGNED', value: (t) => t.assignedTo ?? chalk.dim('—'), maxWidth: 22 },
+        // uid de 28 caracteres (o mesmo que `bug list/claim --assigned-to` aceita):
+        // cortado em 22 virava um uid que não existe (revisão do #75).
+        { header: 'ASSIGNED', value: (t) => t.assignedTo ?? chalk.dim('—'), identificador: true },
     ], res.tickets);
     console.log();
 }