@neetru/cli 2.29.0 → 2.32.0

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.d.ts

@@ -9,6 +9,8 @@ interface InitOptions {
     path?: string;
     /** Modo non-interactive — sai com erro se prompt for necessário. */
     yes?: boolean;
+    /** Não roda `neetru docs init` depois do scaffold (protocolo de docs v1). */
+    semDocs?: boolean;
 }
 export declare function runInit(opts: InitOptions): Promise<void>;
 export {};

package/dist/commands/init.js

@@ -1,7 +1,11 @@
 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 { safeExit } from '../utils/safe-exit.js';
 /**
@@ -81,6 +85,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 { default: inquirer } = await import('inquirer');
     console.log();
     log.info(`Onde você quer inicializar o projeto "${name}"?`);
     console.log();
@@ -271,6 +277,13 @@ export async function runInit(opts) {
             },
         }, null, 2));
         spinner.succeed(mode === 'merge' ? 'Scaffold mesclado!' : 'Projeto criado!');
+        // Protocolo de docs de produto v1 (2026-10-03): o produto nasce com o
+        // mínimo do primeiro dia (README, CHANGELOG, docs/…). Idempotente — em modo
+        // merge nunca sobrescreve doc existente. Falha aqui não derruba o init.
+        if (!opts.semDocs) {
+            const { initDocsAfterScaffold } = await import('./docs-produto.js');
+            await initDocsAfterScaffold(dir);
+        }
         console.log();
         log.info(`Diretório: ${dir}`);
         log.info(`Modo: ${mode === 'merge' ? 'MESCLAR (preserva arquivos existentes)' : 'NOVO (scaffold completo)'}`);

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;

package/dist/commands/mobile.js

@@ -11,11 +11,12 @@
  *   GET    /api/cli/v1/products/{slug}/mobile-apps             — role admin|operator
  *   DELETE /api/cli/v1/products/{slug}/mobile-apps/{appId}     — role admin ONLY + step-up MFA
  *
- * `redirectUri` PRECISA ser `https://` (Universal Link/App Link, RFC 8252) —
- * o Core rejeita custom scheme (`meuapp://`) com 400. Isso é decisão de
- * segurança do owner, não limitação temporária — a CLI valida o mesmo
- * localmente pra falhar rápido com mensagem clara, mas NUNCA oferece
- * custom scheme como alternativa.
+ * `redirectUri` PRECISA ser `https://` (Universal Link/App Link, RFC 8252)
+ * ou `http://localhost`/`http://127.0.0.1` (loopback de dev) — mesma regra
+ * do Core (`validateRedirectUris`). O Core rejeita custom scheme
+ * (`meuapp://`) com 400. Isso é decisão de segurança do owner, não
+ * limitação temporária — a CLI valida o mesmo localmente pra falhar rápido
+ * com mensagem clara, mas NUNCA oferece custom scheme como alternativa.
  *
  * O `id` retornado pelo Core é `<slug>__<platform>` — o app é PKCE público
  * (Authorization Code + PKCE, sem client secret).
@@ -42,6 +43,28 @@ const MOBILE_JSON_REL = '.neetru/mobile.json';
 function jsonError(message, error = 'error') {
     console.log(JSON.stringify({ ok: false, error, message }));
 }
+/**
+ * bug_afcf958a (low): espelha EXATAMENTE a regra de `redirectUri` do Core
+ * (`_oidc-clients-core.ts` → `validateRedirectUris`, usada também pelo
+ * registro de apps mobile em `_product-mobile-apps-core.ts`): aceita
+ * `https://` ou `http://` com host `localhost`/`127.0.0.1` (loopback de
+ * dev, RFC 8252). NUNCA custom scheme (`meuapp://`) — isso o Core rejeita
+ * com 400, decisão de segurança do owner, e a CLI não pode ser MAIS
+ * permissiva que o servidor que vai validar de novo.
+ */
+function isAcceptableMobileRedirectUri(uri) {
+    let parsed;
+    try {
+        parsed = new URL(uri);
+    }
+    catch {
+        return false;
+    }
+    if (parsed.protocol === 'https:')
+        return true;
+    return (parsed.protocol === 'http:' &&
+        (parsed.hostname === 'localhost' || parsed.hostname === '127.0.0.1'));
+}
 function mobileStatusColor(status) {
     switch (status) {
         case 'active': return chalk.green(status);
@@ -82,8 +105,9 @@ export async function runMobileInit(opts = {}) {
         safeExit(1);
         return;
     }
-    if (!redirectUri.startsWith('https://')) {
-        const msg = `--redirect-uri precisa ser https:// (Universal Link/App Link). ` +
+    if (!isAcceptableMobileRedirectUri(redirectUri)) {
+        const msg = `--redirect-uri precisa ser https:// (Universal Link/App Link) ou http://localhost ` +
+            `(ou http://127.0.0.1) para dev — mesma regra do Core. ` +
             `Custom scheme (ex: meuapp://) NÃO é aceito — decisão de segurança do owner (RFC 8252), ` +
             `não é limitação temporária. Recebido: "${redirectUri}"`;
         if (opts.json) {
@@ -269,7 +293,7 @@ export async function runMobileList(opts = {}) {
         return;
     }
     renderTable([
-        { header: 'ID', value: (r) => r.id, maxWidth: 30 },
+        { header: 'ID', value: (r) => r.id, identificador: true },
         { header: 'Platform', value: (r) => r.platform, maxWidth: 10 },
         {
             header: 'Bundle/Package',
@@ -277,7 +301,7 @@ export async function runMobileList(opts = {}) {
             maxWidth: 30,
         },
         { header: 'Status', value: (r) => mobileStatusColor(r.status), maxWidth: 14 },
-        { header: 'OIDC Client ID', value: (r) => r.oidcClientId, maxWidth: 34 },
+        { header: 'OIDC Client ID', value: (r) => r.oidcClientId, identificador: true },
     ], resp.apps);
 }
 /**

package/dist/commands/new.d.ts

@@ -1,6 +1,10 @@
 export interface NewMacroOptions {
     productSlug?: string;
-    env?: 'dev' | 'staging' | 'prod';
+    /**
+     * bug_7dcb68e2666a43f69ef362d2cbff94ed: era `'dev' | 'staging' | 'prod'`.
+     * `'dev'` não existe no enum do Core — ver `../lib/envs.ts`.
+     */
+    env?: string;
     tier?: 'dev' | 'standard' | 'enterprise';
     customer?: string;
     /** Pula scaffold local (útil quando o repo já existe). */
@@ -24,6 +28,32 @@ export interface NewMacroOptions {
      * rodar `neetru db init` manualmente depois.
      */
     skipDbInit?: boolean;
+    /** Não cria o `docs/` do produto no scaffold (repassado ao `runInit`). */
+    semDocs?: boolean;
     json?: boolean;
 }
+/**
+ * Decisão PURA de qual `customerId` a macro deve usar.
+ *
+ * bug_7dcb68e2666a43f69ef362d2cbff94ed — antes a macro assumia `'self'` em
+ * silêncio. `'self'` é um sentinel que o Core só aceita para produto
+ * **Neetru-owned** (`resolveDefaultCustomer`); para qualquer outro produto ele
+ * recusa a criação do workspace. Como a macro cria o produto no passo [1/5] e
+ * o workspace no [2/5], o resultado era um produto órfão no Core e um erro
+ * incompreensível no meio da macro.
+ *
+ * Agora a macro exige `--customer` explícito quando o produto não é
+ * Neetru-owned — e diz isso, em vez de deixar o Core recusar depois.
+ */
+export declare function decidirCustomerDaMacro(entrada: {
+    fromFlag?: string;
+    produtoEhNeetru: boolean;
+    slug: string;
+}): {
+    ok: true;
+    customerId: string;
+} | {
+    ok: false;
+    mensagem: string;
+};
 export declare function runNewMacro(name: string, opts?: NewMacroOptions): Promise<void>;