@neetru/cli 2.31.0 → 2.32.1

package/dist/commands/deployments.js

@@ -13,6 +13,7 @@ import chalk from 'chalk';
 import { apiRequest, CliApiError, CliNetworkError } from '../lib/api-client.js';
 import { requireToken, handleApiError, confirmDestructive, printWriteResult, resolveStepUp, } from '../lib/cli-write.js';
 import { pickProductId, pickServer, pickTenant, promptChoice, promptText } from '../lib/pickers.js';
+import { DEFAULT_TENANT_ENVIRONMENT_ID, ESCOLHAS_AMBIENTE_TENANT, resolverAmbienteTenant, } from '../lib/envs.js';
 import { log } from '../utils/logger.js';
 import { safeExit } from '../utils/safe-exit.js';
 /** Monta o texto do console de deploy (estilo GCP): um bloco por step. */
@@ -39,12 +40,16 @@ export async function runDeploymentsCreate(opts) {
         message: 'Tenant alvo:',
     });
     const version = opts.version ?? (await promptText('Versao:', { json: opts.json }));
-    const env = opts.env ??
-        (await promptChoice('Ambiente:', [
-            { name: 'dev', value: 'dev' },
-            { name: 'staging', value: 'staging' },
-            { name: 'prod', value: 'prod' },
-        ], { default: 'dev', json: opts.json }));
+    // bug_7dcb68e2666a43f69ef362d2cbff94ed: POST /api/cli/v1/deployments valida
+    // environmentId contra ['dev-local','staging','prod'] por igualdade ESTRITA.
+    // Oferecer 'dev' no prompt (e usa-lo como padrao) garantia 400
+    // validation_failed. Alfabeto unico em ../lib/envs.js.
+    const env = opts.env
+        ? resolverAmbienteTenant(opts.env, opts.json)
+        : (await promptChoice('Ambiente:', [...ESCOLHAS_AMBIENTE_TENANT], {
+            default: DEFAULT_TENANT_ENVIRONMENT_ID,
+            json: opts.json,
+        }));
     const server = await pickServer(token, {
         fromFlag: opts.server,
         status: 'online',

package/dist/commands/dev-context.js

@@ -7,12 +7,22 @@ import { listProductDatabases, listProducts, listWorkspaces, resolveProductIdent
 import { requireToken, handleApiError } from '../lib/cli-read.js';
 import { log } from '../utils/logger.js';
 import { safeExit } from '../utils/safe-exit.js';
-function normalizeEnv(value) {
+import { invalidChoiceError } from '../cli-kit/choices.js';
+import { exitWithCliError } from '../lib/cli-error.js';
+/** Ambientes aceitos por `neetru dev sync --env` — validação e mensagem saem daqui. */
+const SYNC_ENVS = ['dev', 'dev-local', 'dev-core'];
+function normalizeEnv(value, json) {
     const raw = (value ?? 'dev').trim().toLowerCase();
-    if (raw === 'dev' || raw === 'dev-local' || raw === 'dev-core')
+    if (SYNC_ENVS.includes(raw))
         return raw;
-    log.error(`Ambiente "${value}" inválido para dev-local. Use: dev | dev-local | dev-core.`);
-    safeExit(1);
+    // bug_89d2497e: a lista da mensagem é a MESMA que validou (`SYNC_ENVS`).
+    return exitWithCliError(invalidChoiceError({
+        flag: '--env',
+        value,
+        valid: SYNC_ENVS,
+        subject: 'Ambiente do dev-local',
+        code: 'invalid_env',
+    }), json);
 }
 function envMatches(rowEnv, wanted) {
     const env = (rowEnv ?? '').toLowerCase();
@@ -79,7 +89,7 @@ async function resolveProductForSync(token, opts) {
 }
 async function syncFromCore(cwd, opts) {
     const token = await requireToken(opts.json);
-    const env = normalizeEnv(opts.env);
+    const env = normalizeEnv(opts.env, opts.json);
     const current = resolveDevContext(cwd);
     if (current?.mode === 'prototype' && !opts.product && !opts.productId) {
         log.error('Este projeto está marcado como protótipo local. Use `neetru dev use --product <slug>` para ligar ao Core.');

package/dist/commands/docs-produto.d.ts

@@ -1,6 +1,7 @@
 import { type CheckResult } from '../lib/product-docs/check.js';
 import { type InitDocsResult } from '../lib/product-docs/ops.js';
 import { type SyncResult } from '../lib/product-docs/sync.js';
+import { NeetruCliError } from '../cli-kit/errors.js';
 export interface DocsInitOptions {
     comApi?: boolean;
     migrar?: boolean;
@@ -37,6 +38,30 @@ export interface DocsSyncOptions {
     offline?: boolean;
     json?: boolean;
 }
+/**
+ * As falhas de envio como UM erro tipado com filhos (P105 / bug_89d2497e,
+ * etapa 3 aplicada ao `docs sync`). Com docs que deram certo (enviados ou já
+ * iguais no Core) a falha se reporta como PARCIAL — no texto ("Falha parcial:
+ * 1 de 3 itens falharam") e no JSON (`partial`, `succeeded`, `failed`,
+ * `children`) — e sai com o código do filho mais grave. `null` sem falhas.
+ */
+export declare function erroDeSyncComFalhas(r: SyncResult): NeetruCliError | null;
+/** O desfecho do `docs sync`, o MESMO para a saída humana e o `--json`. */
+export interface DesfechoDoSync {
+    ok: boolean;
+    exit: number;
+    /** As falhas de envio como erro tipado, ou `null` sem falhas. */
+    erro: NeetruCliError | null;
+}
+/**
+ * Uma regra só para os dois modos (revisão do #87, BAIXO 2). Qualquer doc que
+ * falhou no envio faz o comando falhar com o código do filho mais grave —
+ * MESMO que o lote termine num status informativo (`core-sem-suporte` no meio
+ * do lote: o doc 1 tomou 500 e o doc 2 tomou 405). Antes a saída humana
+ * escondia a falha e saía 0 enquanto o `--json` saía 4. Sem falhas de envio,
+ * vale a regra de sempre: status de `SYNC_FAILURE` sai 1, o resto sai 0.
+ */
+export declare function desfechoDoSync(r: SyncResult): DesfechoDoSync;
 export declare function runDocsSync(opts: DocsSyncOptions): Promise<void>;
 export interface DeployDocsPrecheck {
     ran: boolean;

package/dist/commands/docs-produto.js

@@ -19,6 +19,10 @@ import { checkProductDocs } from '../lib/product-docs/check.js';
 import { resolveTaxonomy } from '../lib/product-docs/taxonomy.js';
 import { createProductDoc, DocsNewError, initProductDocs, migrateProductDocs, } from '../lib/product-docs/ops.js';
 import { syncProductDocs } from '../lib/product-docs/sync.js';
+import { NeetruCliError } from '../cli-kit/errors.js';
+import { CliApiError, CliNetworkError } from '../lib/api-client.js';
+import { cliErrorFromApiError } from '../lib/api-error.js';
+import { exitWithCliError } from '../lib/cli-error.js';
 function fail(json, code, message) {
     if (json)
         console.log(JSON.stringify({ ok: false, error: code, message }));
@@ -207,8 +211,7 @@ function printSync(r) {
         log.warn(`Não enviado (erro no check: ${b.codes.join(', ')}): ${b.file}`);
     for (const x of r.recusados)
         log.warn(`Não pode subir: ${x.file} — ${x.motivo}.`);
-    for (const f of r.falhas)
-        log.error(`Falha em ${f.slug}: ${f.message}`);
+    // As falhas de envio saem no erro tipado (`erroDeSyncComFalhas`), uma vez só.
     if (r.orfaos.length) {
         log.warn(`${r.orfaos.length} doc(s) existem no Core mas não no repositório (nada foi apagado): ${r.orfaos.join(', ')}`);
         log.dim('  A remoção de docs de produto ainda não existe no Core — eles continuam lá até o Core oferecer isso.');
@@ -216,6 +219,52 @@ function printSync(r) {
 }
 /** Status de sync que contam como falha do comando `neetru docs sync`. */
 const SYNC_FAILURE = ['parcial', 'sem-login', 'limite-excedido', 'produto-nao-encontrado', 'falha'];
+/**
+ * Código de saída de um doc que o Core recusou: a MESMA tabela do
+ * `handleApiError` (401→2, 403→3, outro 4xx→1, 5xx e sem resposta→4), lida do
+ * próprio `cliErrorFromApiError` em vez de copiada.
+ */
+function exitDaFalha(httpStatus) {
+    const erro = httpStatus > 0 ? new CliApiError(httpStatus, 'docs_sync', '') : new CliNetworkError('');
+    return cliErrorFromApiError(erro).exit;
+}
+/**
+ * As falhas de envio como UM erro tipado com filhos (P105 / bug_89d2497e,
+ * etapa 3 aplicada ao `docs sync`). Com docs que deram certo (enviados ou já
+ * iguais no Core) a falha se reporta como PARCIAL — no texto ("Falha parcial:
+ * 1 de 3 itens falharam") e no JSON (`partial`, `succeeded`, `failed`,
+ * `children`) — e sai com o código do filho mais grave. `null` sem falhas.
+ */
+export function erroDeSyncComFalhas(r) {
+    if (r.falhas.length === 0)
+        return null;
+    const children = r.falhas.map((f) => new NeetruCliError(f.message, {
+        code: f.httpStatus > 0 ? `http_${f.httpStatus}` : 'sem_resposta',
+        exit: exitDaFalha(f.httpStatus),
+        details: { slug: f.slug, httpStatus: f.httpStatus },
+        human: `Falha em ${f.slug}: ${f.message}`,
+    }));
+    return new NeetruCliError(r.message, {
+        code: r.status === 'parcial' ? 'docs_sync_parcial' : 'docs_sync_falha',
+        children,
+        succeeded: r.enviados.length + r.inalterados.length,
+    });
+}
+/**
+ * Uma regra só para os dois modos (revisão do #87, BAIXO 2). Qualquer doc que
+ * falhou no envio faz o comando falhar com o código do filho mais grave —
+ * MESMO que o lote termine num status informativo (`core-sem-suporte` no meio
+ * do lote: o doc 1 tomou 500 e o doc 2 tomou 405). Antes a saída humana
+ * escondia a falha e saía 0 enquanto o `--json` saía 4. Sem falhas de envio,
+ * vale a regra de sempre: status de `SYNC_FAILURE` sai 1, o resto sai 0.
+ */
+export function desfechoDoSync(r) {
+    const erro = erroDeSyncComFalhas(r);
+    if (erro)
+        return { ok: false, exit: erro.exit, erro };
+    const failed = SYNC_FAILURE.includes(r.status);
+    return { ok: !failed, exit: failed ? 1 : 0, erro: null };
+}
 export async function runDocsSync(opts) {
     const repo = await loadRepoOrExit(opts.json);
     const tax = await resolveTaxonomy({ offline: opts.offline });
@@ -226,22 +275,35 @@ export async function runDocsSync(opts) {
             ? undefined
             : (ms, motivo) => log.dim(`  ${motivo === 'ritmo' ? 'Respeitando o limite de envios do Core' : 'O Core pediu para esperar'}: aguardando ${Math.ceil(ms / 1000)} s…`),
     });
-    const failed = SYNC_FAILURE.includes(r.status);
+    const desfecho = desfechoDoSync(r);
     if (opts.json) {
-        console.log(JSON.stringify({ ok: !failed, ...r }));
-        if (failed)
-            safeExit(1);
+        // O resultado inteiro de antes e, com falhas de envio, o agregado do erro
+        // tipado (`error`, `partial`, `succeeded`, `failed`, `children`).
+        let agregado = {};
+        if (desfecho.erro) {
+            const { ok: _ok, ...resto } = desfecho.erro.toJSON();
+            agregado = resto;
+        }
+        console.log(JSON.stringify({ ok: desfecho.ok, ...r, ...agregado }));
+        if (desfecho.exit !== 0)
+            safeExit(desfecho.exit);
         return;
     }
     log.heading(`Publicar docs de ${repo.slug} no Core${r.dryRun ? ' (simulação)' : ''}`);
     printSync(r);
+    if (desfecho.erro) {
+        // O cabeçalho é a mensagem do status (inclusive o "Core sem suporte"); as
+        // falhas de envio vêm logo abaixo, uma por doc — nunca somem.
+        exitWithCliError(desfecho.erro, false);
+        return;
+    }
     if (r.status === 'core-sem-suporte' || r.status === 'desligado' || r.status === 'nada-a-enviar') {
         log.info(r.message);
         return;
     }
-    if (failed) {
+    if (desfecho.exit !== 0) {
         log.error(r.message);
-        safeExit(1);
+        safeExit(desfecho.exit);
     }
     log.success(r.message);
 }

package/dist/commands/doctor.js

@@ -25,7 +25,13 @@ import { log } from '../utils/logger.js';
 // Fix do bug onde 2.0.0 ficava hardcoded depois de bumps.
 import { CLI_VERSION } from '../version.js';
 import { safeExit } from '../utils/safe-exit.js';
+import { RUNTIME_ENVIRONMENT_IDS, TENANT_ENVIRONMENT_IDS } from '../lib/envs.js';
 const NPM_REGISTRY = 'https://registry.npmjs.org/@neetru/cli';
+/**
+ * `NEETRU_ENV` que o doctor ainda aceita sem estar em alfabeto nenhum — legado
+ * declarado (ver `checkNeetruEnv`), candidato a deprecação.
+ */
+const NEETRU_ENV_LEGADOS = ['beta'];
 /* ── Checks individuais — exportados pra teste ────────────────────── */
 export async function checkToken() {
     const t = getActiveTokenSync();
@@ -92,7 +98,36 @@ export async function checkConfigSchema(cwd) {
 export async function checkNeetruEnv(cwd) {
     // bug: 'production' não é valor canônico do SDK/Core — o correto é 'prod'.
     // 'production' causava doctor OK mas runtime falhava ao comparar NEETRU_ENV.
-    const valid = ['dev', 'workspace', 'beta', 'prod'];
+    // 2026-10-12: a lista rejeitava `dev-local`, que o Core INJETA.
+    //
+    // O Core grava `NEETRU_ENV = environmentId` no deploy
+    // (`_vm-deploy-readiness.ts:9` e `:76`), e `environmentId` só pode ser
+    // `dev-local`, `staging` ou `prod` (`ENVIRONMENT_IDS`, schemas/envs.ts:39).
+    // Com `dev-local` fora desta lista, o doctor reprovava com exit 1 uma
+    // configuração que o próprio Core tinha acabado de escrever — e em CI isso
+    // quebra o build sobre uma config correta.
+    //
+    // `staging` entra aqui pelo mesmo motivo (o Core o produz), mas com uma
+    // ressalva REGISTRADA e não resolvida: o tipo `NeetruEnv` do SDK
+    // (`src/types.ts:873`) lista `dev | workspace | prod | dev-local` e NÃO
+    // inclui `staging`. Procurei o guard de runtime (`resolveNeetruEnv`) e ele
+    // não existe no `dist` publicado do SDK — só é citado na doc e no código de
+    // deploy do Core. Então NÃO consegui confirmar se `staging` quebra em
+    // runtime. O doctor para de reprovar (o Core produz esse valor), e a dúvida
+    // fica anotada em vez de virar silêncio nos dois sentidos.
+    //
+    // `workspace` e `beta` ficam por compatibilidade: estavam aceitos antes e
+    // remover valor de uma lista de validação quebra quem já configurou. `beta`
+    // não aparece em nenhum alfabeto atual — candidato a deprecação declarada,
+    // não a remoção silenciosa.
+    //
+    // P105: a lista era escrita à mão. Agora é a UNIÃO das duas fontes — o
+    // `NEETRU_ENV` do SDK (`RUNTIME_ENVIRONMENT_IDS`) e o `environmentId` que o
+    // Core injeta (`TENANT_ENVIRONMENT_IDS`) — mais o legado declarado abaixo.
+    // Mesmo conjunto de antes; só a ordem do texto "esperado …" mudou.
+    const valid = [
+        ...new Set([...RUNTIME_ENVIRONMENT_IDS, ...TENANT_ENVIRONMENT_IDS, ...NEETRU_ENV_LEGADOS]),
+    ];
     // Procura .env.local pra ver NEETRU_ENV.
     try {
         const raw = await fs.readFile(path.join(cwd, '.env.local'), 'utf8');

package/dist/commands/domains.js

@@ -53,6 +53,56 @@ function outcomeColor(outcome) {
         default: return chalk.dim(outcome);
     }
 }
+/**
+ * Texto plain PT-BR do motivo de um `outcome: 'skipped'` (bug_6e9fe576).
+ * `stage_sem_subdominio`/`subdomain_cloud_run_unsupported` são esperados
+ * (dev-local e produto Cloud Run nunca têm domínio por VM); os outros dois
+ * exigem ação de quem pediu o reconcile. `undefined` cobre o Core anterior
+ * ao #677, que nunca manda `reason` — nesse caso dizemos isso explicitamente
+ * em vez de deixar a célula vazia (o ponto do bug original era exatamente
+ * "pulei e não disse por quê").
+ */
+function skipReasonText(reason) {
+    switch (reason) {
+        case 'stage_sem_subdominio':
+            return 'ambiente local, sem domínio público (esperado)';
+        case 'subdomain_cloud_run_unsupported':
+            return 'produto Cloud Run, não usa domínio por VM (esperado)';
+        case 'subdomain_deploy_config_missing':
+            return 'ambiente sem configuração de deploy — corrija o ambiente';
+        case 'subdomain_hard_cap_reached':
+            return 'limite de subdomínios atingido — requer ação do operador';
+        default:
+            return 'motivo não informado por este Core (atualize o Core para ver detalhes)';
+    }
+}
+/** Célula da coluna "Motivo/erro" — reason em pulados, err em erros, vazio nos demais. */
+function reconcileNote(r) {
+    if (r.outcome === 'skipped')
+        return skipReasonText(r.reason);
+    if (r.outcome === 'error')
+        return r.err ?? '';
+    return '';
+}
+/** Pulados que exigem ação de quem pediu o reconcile (os outros dois são esperados). */
+const SKIP_EXIGE_ACAO = new Set([
+    'subdomain_deploy_config_missing',
+    'subdomain_hard_cap_reached',
+]);
+/**
+ * A execução teve erro? Olha a contagem `errors` ALÉM do `ok` do Core: o Core
+ * anterior ao #677 manda `ok: true` FIXO mesmo com erro (é o próprio
+ * bug_6e9fe576), e a CLI publicada conversa com ele até o deploy. Decidir só
+ * pelo `ok` reabria a mentira: "Erros: 1" seguido de "tudo já existe" com
+ * exit 0 (revisão do cli#80).
+ */
+function reconcileFalhou(resp) {
+    return resp.ok === false || resp.errors > 0;
+}
+/** Ambientes pulados por um motivo que exige ação (só o Core #677+ informa o motivo). */
+function pendentesDeAcao(resp) {
+    return resp.details.filter((r) => r.outcome === 'skipped' && r.reason !== undefined && SKIP_EXIGE_ACAO.has(r.reason));
+}
 export async function runDomainsList(opts) {
     if (!opts.product) {
         const msg = '--product <slug> é obrigatório.';
@@ -95,7 +145,7 @@ export async function runDomainsList(opts) {
         { header: 'Cert', value: (r) => certStatusColor(r.certStatus), maxWidth: 18 },
         { header: 'Alvo', value: (r) => r.targetKind ?? '—', maxWidth: 14 },
         { header: 'Porta', value: (r) => r.upstreamPort != null ? String(r.upstreamPort) : '—', maxWidth: 8 },
-        { header: 'VM', value: (r) => r.serverId ?? '—', maxWidth: 22 },
+        { header: 'VM', value: (r) => r.serverId ?? '—', identificador: true },
         { header: 'Atualizado', value: (r) => fmtTimestamp(r.updatedAt), maxWidth: 20 },
     ], resp.subdomains);
 }
@@ -127,8 +177,15 @@ export async function runDomainsReconcile(opts) {
         spinner?.fail('Falha ao reconciliar domínios.');
         handleApiError(err, opts.json);
     }
+    // bug_6e9fe576: `ok:false` é o Core sinalizando que a execução teve erro
+    // real (não é exceção de rede/HTTP — a resposta é 200, o resumo que reporta
+    // a falha). Trata igual ao resto da CLI que agrega um resultado em lote
+    // (`doctor`/`smoke`): --json imprime o corpo e sai já com o código certo,
+    // sem cair nos prints humanos abaixo.
     if (opts.json) {
         console.log(JSON.stringify(resp));
+        if (reconcileFalhou(resp) || pendentesDeAcao(resp).length > 0)
+            safeExit(1);
         return;
     }
     log.heading(`Reconcile — "${chalk.bold(resp.productSlug)}"`);
@@ -147,15 +204,39 @@ export async function runDomainsReconcile(opts) {
             { header: 'Resultado', value: (r) => outcomeColor(r.outcome), maxWidth: 12 },
             { header: 'FQDN', value: (r) => r.fqdn || '—', maxWidth: 44 },
             { header: 'Status', value: (r) => subdomainStatusColor(r.status), maxWidth: 18 },
-            { header: 'Erro', value: (r) => r.err ?? '', maxWidth: 40 },
+            { header: 'Motivo/erro', value: reconcileNote, maxWidth: 46 },
         ], resp.details);
     }
+    // bug_6e9fe576: "Todos os domínios obrigatórios já existem." era impresso
+    // mesmo com `skipped > 0` — dois ambientes target=workspace, nada criado,
+    // nada existente, e a CLI dizia que tudo estava ok. Agora a frase de
+    // sucesso-sem-criação só sai quando NADA foi pulado; com pulados, aponta
+    // pra tabela acima (que já tem o motivo, com ou sem `reason` do Core).
+    const falhou = reconcileFalhou(resp);
+    const exigeAcao = pendentesDeAcao(resp);
     if (resp.created > 0) {
         log.success(`${resp.created} subdomínio(s) criado(s). Execute \`neetru domains list --product ${opts.product}\` para ver o status.`);
     }
-    else if (resp.errors === 0) {
-        log.success('Todos os domínios obrigatórios já existem.');
+    if (falhou) {
+        log.error('Reconcile encontrou erro(s). Veja os detalhes acima.');
     }
+    if (exigeAcao.length > 0) {
+        const quais = exigeAcao.map((r) => r.envType).join(', ');
+        log.warn(`${exigeAcao.length} ambiente(s) precisam de ação (${quais}) — o domínio não foi garantido. Veja o motivo na tabela acima.`);
+    }
+    if (resp.created === 0 && !falhou && exigeAcao.length === 0) {
+        if (resp.skipped > 0) {
+            log.warn(`Nenhum domínio criado — ${resp.skipped} ambiente(s) pulado(s). Veja o motivo na tabela acima.`);
+        }
+        else {
+            log.success('Todos os domínios obrigatórios já existem.');
+        }
+    }
+    // Exit 1 quando houve erro (pela contagem local, não só pelo `ok` do Core) ou
+    // quando um ambiente ficou sem domínio por um motivo que exige ação — como o
+    // doctor/smoke, que derivam o exit do resultado que a própria CLI conta.
+    if (falhou || exigeAcao.length > 0)
+        safeExit(1);
 }
 export async function runDomainsRetry(opts) {
     if (!opts.product) {

package/dist/commands/env.d.ts

@@ -1,6 +1,12 @@
-declare const SUPPORTED: readonly ["dev", "workspace", "prod", "production"];
-export type EnvTarget = (typeof SUPPORTED)[number];
-type StoredEnvTarget = 'dev' | 'workspace' | 'prod';
+import { type RuntimeEnvironmentId } from '../lib/envs.js';
+/**
+ * O `NEETRU_ENV` do SDK sai da tabela `VOCABULARIOS_DE_AMBIENTE` (`lib/envs.ts`,
+ * P105) — era `['dev','workspace','prod']` escrito à mão — mais o apelido
+ * `production`, aceito na entrada e gravado como `prod`.
+ */
+declare const APELIDO_PRODUCTION = "production";
+export type EnvTarget = RuntimeEnvironmentId | typeof APELIDO_PRODUCTION;
+type StoredEnvTarget = RuntimeEnvironmentId;
 export interface EnvSwitchOptions {
     target: string;
     cwd?: string;

package/dist/commands/env.js

@@ -8,7 +8,15 @@ import * as fs from 'node:fs/promises';
 import * as fsSync from 'node:fs';
 import * as path from 'node:path';
 import { log } from '../utils/logger.js';
-const SUPPORTED = ['dev', 'workspace', 'prod', 'production'];
+import { problemaDeCodificacao, recusaDoEnvSwitch } from '../lib/texto-utf8.js';
+import { RUNTIME_ENVIRONMENT_IDS } from '../lib/envs.js';
+/**
+ * O `NEETRU_ENV` do SDK sai da tabela `VOCABULARIOS_DE_AMBIENTE` (`lib/envs.ts`,
+ * P105) — era `['dev','workspace','prod']` escrito à mão — mais o apelido
+ * `production`, aceito na entrada e gravado como `prod`.
+ */
+const APELIDO_PRODUCTION = 'production';
+const SUPPORTED = [...RUNTIME_ENVIRONMENT_IDS, APELIDO_PRODUCTION];
 /**
  * Normaliza um target de ambiente (aceita o alias `production` → `prod`) ou
  * `null` se não reconhecido. Exportada (2026-07-22) pra `neetru build
@@ -18,7 +26,7 @@ const SUPPORTED = ['dev', 'workspace', 'prod', 'production'];
 export function normalizeTarget(t) {
     if (!SUPPORTED.includes(t))
         return null;
-    return t === 'production' ? 'prod' : t;
+    return t === APELIDO_PRODUCTION ? 'prod' : t;
 }
 /**
  * Substitui ou adiciona `NEETRU_ENV=<value>` em `content` (texto do .env).
@@ -60,7 +68,19 @@ export async function runEnvSwitch(opts) {
     const filePath = path.join(cwd, file);
     let content = '';
     if (fsSync.existsSync(filePath)) {
-        content = await fs.readFile(filePath, 'utf-8');
+        // Rodada final 2 do cli#81 (BAIXA): `readFile(…, 'utf-8')` trocava cada
+        // byte que não é UTF-8 por U+FFFD, e a regravação abaixo levava a troca ao
+        // disco — um ANSI com `Café` terminava `Caf\uFFFD`, com exit 0 e "✓".
+        // Agora lê em bytes e recusa ANTES de gravar o que a regravação estragaria.
+        const bruto = await fs.readFile(filePath);
+        const problema = problemaDeCodificacao(bruto);
+        if (problema === 'utf16' || problema === 'nao-utf8') {
+            log.error(recusaDoEnvSwitch(file, problema).message);
+            safeExit(1);
+            return;
+        }
+        // A marca BOM fica no texto e volta ao disco como estava.
+        content = bruto.toString('utf8');
     }
     const updated = applyEnvSwitch(content, storedTarget);
     await fs.writeFile(filePath, updated, 'utf-8');

package/dist/commands/infra-read.js

@@ -68,7 +68,7 @@ export async function runHostingList(opts) {
     }
     renderTable([
         { header: 'HOST', value: (d) => d.host ?? '—', maxWidth: 32 },
-        { header: 'TENANT', value: (d) => d.tenantId ?? '—', maxWidth: 22 },
+        { header: 'TENANT', value: (d) => d.tenantId ?? '—', identificador: true },
         { header: 'STATUS', value: (d) => d.status ?? '—' },
         { header: 'CERT', value: (d) => d.certStatus ?? '—' },
         { header: 'TARGET', value: (d) => d.targetService ?? '—', maxWidth: 24 },
@@ -98,7 +98,7 @@ export async function runBuildsList(opts) {
     }
     log.heading(`Cloud Builds (${res.builds.length})`);
     renderTable([
-        { header: 'ID', value: (b) => b.id, maxWidth: 36 },
+        { header: 'ID', value: (b) => b.id, identificador: true },
         { header: 'STATUS', value: (b) => b.status },
         { header: 'REGIÃO', value: (b) => b.region ?? 'global' },
         { header: 'SOURCE', value: (b) => b.source ?? '—', maxWidth: 28 },

package/dist/commands/init.js

@@ -1,8 +1,13 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import ora from 'ora';
-import inquirer from 'inquirer';
+// `inquirer` NÃO é importado aqui: só o caminho interativo de `resolveTarget`
+// pergunta, e ele o carrega na hora (P112, 2026-10-18). O import a frio do
+// inquirer custava ~0,35 s sozinho e ~1,1 s com a suíte rodando — pago por
+// todo `neetru init --yes` (CI e scripts) e pelo 1º teste do init.test.ts,
+// que estourava o timeout de 10 s com a máquina carregada.
 import { log } from '../utils/logger.js';
+import { carregarInquirer } from '../lib/inquirer-sob-demanda.js';
 import { safeExit } from '../utils/safe-exit.js';
 /**
  * Inspeciona um diretório pra decidir se é projeto existente, vazio, ou
@@ -81,6 +86,8 @@ async function resolveTarget(name, cwd, opts) {
         return { dir: subDir, mode: 'new', force: false };
     }
     // ── Interactive ──────────────────────────────────────────────────────
+    // Só aqui há pergunta: o inquirer é carregado agora (ver o topo do arquivo).
+    const inquirer = await carregarInquirer();
     console.log();
     log.info(`Onde você quer inicializar o projeto "${name}"?`);
     console.log();

package/dist/commands/login.js

@@ -21,6 +21,7 @@ import { spawn } from 'node:child_process';
 import { config } from '../lib/config.js';
 import { saveToken } from '../lib/auth.js';
 import { apiRequest, CliApiError, CliNetworkError } from '../lib/api-client.js';
+import { discardMfaSessionOfOtherUid } from '../lib/cli-write.js';
 import { log } from '../utils/logger.js';
 import { safeExit } from '../utils/safe-exit.js';
 const TOKEN_PATTERN = /^nrt_[a-z0-9]{8,16}_[A-Za-z0-9_\-=]{20,64}$/;
@@ -51,28 +52,52 @@ function openBrowser(url) {
     catch {
         return; // URL inválida → não abre (caller já imprimiu pra copiar/colar)
     }
+    // bug_d414f21c (medium): sem binário de abrir browser (ex.: WSL sem
+    // `xdg-open`), `spawn(...)` emite 'error' (ENOENT) ASSINCRONAMENTE — sem
+    // listener, o Node trata como exceção não capturada e derruba o processo,
+    // abortando o polling do device-code antes de começar. Registra o handler
+    // e avisa o usuário (ele já tem a URL impressa pra copiar/colar); nunca
+    // deixa esse erro propagar.
+    const warnFallback = () => {
+        log.warn('Não consegui abrir o navegador; abra a URL acima manualmente.');
+    };
     try {
+        let child;
         if (process.platform === 'win32') {
-            spawn('rundll32', ['url.dll,FileProtocolHandler', url], {
+            child = spawn('rundll32', ['url.dll,FileProtocolHandler', url], {
                 detached: true,
                 stdio: 'ignore',
                 windowsHide: true,
-            }).unref();
-            return;
+            });
         }
-        if (process.platform === 'darwin') {
-            spawn('open', [url], { detached: true, stdio: 'ignore' }).unref();
-            return;
+        else if (process.platform === 'darwin') {
+            child = spawn('open', [url], { detached: true, stdio: 'ignore' });
+        }
+        else {
+            child = spawn('xdg-open', [url], { detached: true, stdio: 'ignore' });
         }
-        spawn('xdg-open', [url], { detached: true, stdio: 'ignore' }).unref();
+        child.on('error', warnFallback);
+        child.unref();
     }
     catch {
-        // ignore — caller já printou a URL.
+        warnFallback();
     }
 }
 function sleep(ms) {
     return new Promise((res) => setTimeout(res, ms));
 }
+/**
+ * A8 (2026-10-13): o login trocava o Bearer mas mantinha o `mfa-session.json`
+ * da conta anterior. O Core só aceita sessão MFA do MESMO uid do Bearer, então
+ * por até 1h todo comando destrutivo da conta nova tomava 401. Sessão de outro
+ * uid sai junto com a troca de conta; a da mesma conta fica.
+ */
+async function discardForeignMfaSession(uid, json) {
+    if (await discardMfaSessionOfOtherUid(uid)) {
+        if (!json)
+            log.dim('Sessão MFA de 1h da conta anterior descartada (rode `neetru auth mfa-session` se precisar).');
+    }
+}
 async function pollForToken(deviceCode, initialIntervalSec, expiresAtMs, json) {
     let intervalMs = initialIntervalSec * 1000;
     const spinner = json
@@ -143,6 +168,7 @@ export async function runLogin(opts = {}) {
             const path = await saveToken(token, me.email);
             // Compat: alguns comandos legados ainda leem do Conf.
             config.set('neetruApiKey', token);
+            await discardForeignMfaSession(me.uid, json);
             if (json) {
                 emitJson({ ok: true, email: me.email, role: me.role, path });
             }
@@ -213,6 +239,7 @@ export async function runLogin(opts = {}) {
         const path = await saveToken(accessToken, me.email);
         // Compat: legacy commands podem usar Conf — mantemos o token lá também.
         config.set('neetruApiKey', accessToken);
+        await discardForeignMfaSession(me.uid, json);
         if (json) {
             emitJson({ ok: true, email: me.email, role: me.role, path });
         }

package/dist/commands/logs.js

@@ -10,9 +10,8 @@
 import { existsSync, readFileSync, statSync, openSync, readSync, closeSync } from 'node:fs';
 import { join } from 'node:path';
 import chalk from 'chalk';
-import { apiRequest, CliNetworkError } from '../lib/api-client.js';
+import { apiRequest, CliNetworkError, resolveTrustedApiUrl } from '../lib/api-client.js';
 import { handleApiError } from '../lib/api-error.js';
-import { config } from '../lib/config.js';
 import { getActiveTokenSync } from '../lib/token-resolver.js';
 import { log } from '../utils/logger.js';
 import { safeExit } from '../utils/safe-exit.js';
@@ -239,7 +238,6 @@ async function fetchLogs(clientId, params) {
 async function runSseFollow(clientId, opts, jsonMode) {
     // MASTER-HIGH-048 (2.11.0): SSE stream usa o mesmo resolver canonico.
     const apiKey = getActiveTokenSync() ?? undefined;
-    const apiBase = config.get('apiBase') ?? 'https://api.neetru.com';
     const qs = new URLSearchParams({ clientId });
     if (opts.level)
         qs.set('level', opts.level);
@@ -249,7 +247,17 @@ async function runSseFollow(clientId, opts, jsonMode) {
         qs.set('channel', opts.channel);
     if (opts.correlationId)
         qs.set('correlationId', opts.correlationId);
-    const streamUrl = `${apiBase}/api/cli/v1/logs/stream?${qs.toString()}`;
+    // C7 (2026-10-13): a base e a guarda são as MESMAS do `apiRequest` (que fez o
+    // primeiro request deste comando). Antes o stream lia `config.get('apiBase')`
+    // — chave fora do schema — e mandava o Bearer pra qualquer host gravado ali,
+    // além de ignorar o `neetruApiUrl` de staging/local.
+    let streamUrl;
+    try {
+        streamUrl = resolveTrustedApiUrl(`/api/cli/v1/logs/stream?${qs.toString()}`);
+    }
+    catch (error) {
+        handleApiError(error, jsonMode);
+    }
     let attempts = 0;
     const MAX_RECONNECTS = 5;
     let lastEventId;