@neetru/cli 2.31.0 → 2.32.0

package/dist/lib/pickers.js

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import inquirer from 'inquirer';
 import { apiRequest } from './api-client.js';
 import { handleApiError } from './api-error.js';
+import { adviseCommand, declaredInputs } from '../cli-kit/command-context.js';
 import { log } from '../utils/logger.js';
 import { safeExit } from '../utils/safe-exit.js';
 export function isInteractive(opts = {}) {
@@ -26,12 +27,32 @@ function failLookup(error, json) {
     // →2) divergentes dos comandos, contribuindo pro conflito que quebrava CI.
     return handleApiError(error, json);
 }
+/**
+ * A entrada que o conselho pode citar, já validada contra o comando em
+ * execução: `'--tenant'`, `'<id>'`, `'<serverId> ou --server'`… — ou `null`
+ * quando o comando não declara nenhuma das candidatas (ou não há comando).
+ *
+ * P105: o texto fixo citava a entrada padrão do picker. Medido na árvore do
+ * Commander em 2026-10-18, ela não existia em 10 comandos: `tenants get|
+ * update|suspend|reactivate` (recebem `[id]`, não `--tenant`), `servers
+ * deactivate|dispatch` (`[serverId]`, não `--server`), `products publish|
+ * unpublish` (`[slug]`, não `--product`) e `admin database create`/`products
+ * db create` (`--product-id`/`--server-id`, não `--product`/`--server`).
+ */
+export function entradaDoPicker(opts) {
+    const declaradas = declaredInputs(opts.inputs ?? [opts.flagName]);
+    return declaradas.length > 0 ? declaradas.join(' ou ') : null;
+}
 export async function resolveOrPick(opts) {
     const flagged = opts.fromFlag?.trim();
     if (flagged)
         return flagged;
+    const entrada = entradaDoPicker(opts);
+    const sujeito = opts.subject ?? 'o valor';
     if (opts.json) {
-        failInput(`${opts.flagName} e obrigatorio em modo --json.`, true);
+        failInput(entrada
+            ? `${entrada} e obrigatorio em modo --json.`
+            : `Este comando precisa escolher ${sujeito} e, em modo --json, não há como perguntar qual.`, true);
     }
     let items;
     try {
@@ -50,7 +71,10 @@ export async function resolveOrPick(opts) {
         const available = items
             .map((item) => `  - ${opts.getId(item)}: ${stripAnsi(opts.format(item))}`)
             .join('\n');
-        failInput(`Multiplos candidatos encontrados. Passe ${opts.flagName} explicitamente.\nDisponiveis:\n${available}`, opts.json);
+        failInput(entrada
+            ? `Multiplos candidatos encontrados. Passe ${entrada} explicitamente.\nDisponiveis:\n${available}`
+            : `Múltiplos candidatos encontrados, e este comando não recebe ${sujeito} por argumento: ` +
+                `rode num terminal interativo para escolher.\nDisponiveis:\n${available}`, opts.json);
     }
     const choices = items.map((item) => ({
         name: opts.format(item),
@@ -122,6 +146,21 @@ export async function promptChoice(message, choices, opts = {}) {
 // Slugs Neetru-owned conhecidos no cliente CLI (espelho do fallback server-side).
 // Atualizar junto com NEETRU_PRODUCT_SLUGS_FALLBACK em resolve-default.ts.
 const NEETRU_SLUGS_CLI = ['gestovendas', 'pdv-agiliza'];
+/**
+ * Versão só-slug da heurística abaixo, para quando o produto AINDA NÃO existe
+ * no Core — caso do `neetru new`, que precisa decidir o customer antes de
+ * criar qualquer coisa.
+ *
+ * bug_7dcb68e2666a43f69ef362d2cbff94ed: como a lista de fallback tem apenas
+ * dois slugs, todo produto novo cai no caminho "não é Neetru-owned", que é
+ * justamente o caminho em que o Core exige `--customer`. O ponto é avisar
+ * ANTES, e não quebrar no passo [2/5] com o produto já criado.
+ */
+export function isNeetruOwnedSlug(slug) {
+    if (!slug)
+        return false;
+    return NEETRU_SLUGS_CLI.includes(slug.trim().toLowerCase());
+}
 /**
  * Verifica (via GET /api/cli/v1/products/{id}) se um produto é Neetru-owned.
  * Usa heurísticas de cliente: ownedBy==='neetru' | ownerTeam==='Neetru Core' | slug fallback.
@@ -220,6 +259,17 @@ export function productLabel(product) {
     const team = product.ownerTeam ? chalk.dim(`- ${product.ownerTeam}`) : '';
     return compact([statusDot(product.status), chalk.bold(name), slug, status, team]).join(' ');
 }
+/**
+ * "Nenhum produto": a dica de criar só cita `neetru products create` se o
+ * comando existe na árvore (P105).
+ */
+function semProdutoAinda() {
+    return adviseCommand({
+        command: 'products create',
+        withCommand: 'Nenhum produto encontrado. Crie com: neetru products create',
+        withoutCommand: 'Nenhum produto encontrado.',
+    });
+}
 export async function pickProductId(token, opts = {}) {
     return resolveOrPick({
         ...opts,
@@ -227,8 +277,9 @@ export async function pickProductId(token, opts = {}) {
         format: productLabel,
         getId: (product) => product.id,
         message: opts.message ?? 'Escolha o produto:',
-        emptyError: 'Nenhum produto encontrado. Crie com: neetru products create',
+        emptyError: semProdutoAinda(),
         flagName: '--product',
+        subject: 'o produto',
     });
 }
 /**
@@ -272,8 +323,9 @@ export async function pickProductSlug(token, opts = {}) {
         format: productLabel,
         getId: (product) => product.slug ?? product.id,
         message: opts.message ?? 'Escolha o produto:',
-        emptyError: 'Nenhum produto encontrado. Crie com: neetru products create',
+        emptyError: semProdutoAinda(),
         flagName: '--product',
+        subject: 'o produto',
     });
 }
 export async function pickTenant(token, opts = {}) {
@@ -285,6 +337,7 @@ export async function pickTenant(token, opts = {}) {
         message: opts.message ?? 'Escolha o tenant:',
         emptyError: 'Nenhum tenant encontrado no escopo atual.',
         flagName: '--tenant',
+        subject: 'o tenant',
     });
 }
 export async function pickWorkspace(token, opts = {}) {
@@ -296,6 +349,7 @@ export async function pickWorkspace(token, opts = {}) {
         message: opts.message ?? 'Escolha o workspace:',
         emptyError: 'Nenhum workspace encontrado no escopo atual.',
         flagName: '<workspaceId>',
+        subject: 'o workspace',
     });
 }
 export async function pickServer(token, opts = {}) {
@@ -307,6 +361,7 @@ export async function pickServer(token, opts = {}) {
         message: opts.message ?? 'Escolha o server:',
         emptyError: 'Nenhum server encontrado no escopo atual.',
         flagName: '--server',
+        subject: 'o server',
     });
 }
 export async function pickDatabase(token, opts = {}) {
@@ -322,6 +377,7 @@ export async function pickDatabase(token, opts = {}) {
         message: opts.message ?? 'Escolha o banco:',
         emptyError: 'Nenhum banco encontrado no escopo atual.',
         flagName: '<id>',
+        subject: 'o banco',
     });
 }
 function workspaceLabel(workspace) {

package/dist/lib/product-docs/sync.d.ts

@@ -53,9 +53,15 @@ export interface SyncResult {
         file: string;
         codes: string[];
     }>;
+    /**
+     * Docs que o Core recusou. `httpStatus` é o status da resposta (0 = sem
+     * resposta HTTP: rede, timeout) — é dele que sai o código de saída de cada
+     * falha no `neetru docs sync` (P105).
+     */
     falhas: Array<{
         slug: string;
         message: string;
+        httpStatus: number;
     }>;
     /** Não enviados por regra do Core conferida localmente (slug, tamanho). */
     recusados: Array<{

package/dist/lib/product-docs/sync.js

@@ -294,13 +294,22 @@ export async function syncProductDocs(repo, opts) {
                 base.falhas.push({
                     slug: d.slug,
                     message: status === 413 ? `grande demais para o Core (${msg})` : status === 429 ? `limite de envios do Core (${msg}) — tente de novo em alguns minutos` : msg,
+                    httpStatus: status,
                 });
                 break;
             }
         }
     }
     if (base.falhas.length) {
-        return { ...base, status: 'parcial', message: `${base.enviados.length} enviado(s), ${base.falhas.length} com falha.` };
+        // P105: "parcial" só quando algo deu certo (enviado ou já igual no Core).
+        // Com tudo falhando, dizer "parcial" era o mesmo tipo de mentira do
+        // bug_6e9fe576 ao contrário — o status passa a ser `falha`.
+        const deuCerto = base.enviados.length + base.inalterados.length;
+        return {
+            ...base,
+            status: deuCerto > 0 ? 'parcial' : 'falha',
+            message: `${base.enviados.length} enviado(s), ${base.falhas.length} com falha.`,
+        };
     }
     return {
         ...base,

package/dist/lib/public-secret-scan.d.ts

@@ -1,3 +1,4 @@
+import { type ProblemaDeCodificacao } from './texto-utf8.js';
 export interface SecretPattern {
     id: 'nrt_key' | 'npk_key' | 'private_key';
     label: string;
@@ -40,17 +41,57 @@ export interface ScanResult {
     /** Arquivos públicos grandes demais para varrer (caminhos). */
     skippedLarge: string[];
 }
-/** Varre um conteúdo de arquivo. Dedup por (arquivo, padrão). */
+/**
+ * Regex que acha o valor no pacote com cada caractere que pode sair escapado
+ * em qualquer uma das suas formas, letra a letra: o SWC do Next mistura as
+ * formas dentro do MESMO valor (`chave-€-łódź` sai com `€`, `ł` e `ź` crus
+ * e `ó` como `\xf3`). `emBytes` diz se o pacote foi lido em latin1 (a forma
+ * crua é então a dos bytes UTF-8). Devolve `null` quando nenhum caractere do
+ * valor pode sair escapado: aí basta `includes`.
+ */
+export declare function padraoDoValorNoPacote(valor: string, emBytes: boolean): RegExp | null;
+/**
+ * Varre um conteúdo de arquivo. Um achado por (arquivo, padrão): desde a
+ * rodada final 5 do cli#81 cada nome tem até três valores procurados (o do
+ * Next, o do Vite e o cru), e quando um é pedaço do outro os dois casavam. A
+ * busca do nome para no primeiro valor achado.
+ */
 export declare function scanContent(file: string, content: Buffer | string, envSecrets: readonly PublicEnvSecret[]): PublicSecretFinding[];
-/** Parser mínimo de .env (KEY=VALUE, aspas simples/duplas, comentários). */
+/**
+ * Lê o .env com a regra do dotenv, a MESMA que o `@next/env` 15.5 e o Vite 5.4
+ * embutem (copiada dos dois no `node_modules` da core-deps; rodada final 4 do
+ * cli#81). A varredura procura no pacote o valor que o bundler leu, e o parser
+ * mínimo de antes divergia em quatro pontos, medidos num `next build` real:
+ *   - `CHAVE=valor # nota`: o dotenv corta no `#`; o parser antigo levava a nota;
+ *   - valor entre crases: o dotenv tira as crases; o antigo não;
+ *   - `CHAVE="a\nb"`: entre aspas duplas, o dotenv troca `\n` e `\r` pela
+ *     quebra de linha e pelo retorno; o antigo deixava a barra e a letra;
+ *   - valor entre aspas em mais de uma linha: o dotenv junta; o antigo cortava.
+ */
 export declare function parseDotenv(content: string): Record<string, string>;
 /** Arquivos .env que o bundler lê num build de produção (o `.env*` NÃO viaja no tarball). */
 export declare const BUILD_ENV_FILES: readonly [".env", ".env.production", ".env.local", ".env.production.local"];
 /**
  * Coleta envs públicas com nome sensível a partir do ambiente do build:
  * `.env*` do projeto, `--env-file` e `process.env` do CLI (o build roda com ele).
+ *
+ * Rodada final 2 do cli#81: cada arquivo é lido COMO O BUNDLER O LÊ, porque a
+ * varredura procura no pacote o valor que o bundler gravou lá. O `@next/env`
+ * (Next 15.5) lê o `.env` com `readFileSync(…, "utf8")` e o Vite 5.4 passa os
+ * bytes ao `dotenv`, que faz `toString()`: os dois trocam byte que não é UTF-8
+ * por U+FFFD, e é esse valor trocado que vai ao JS do navegador. Por isso aqui
+ * a leitura NÃO recusa (como faz o `--env-file`, que a CLI injeta ela mesma):
+ * recusar esconderia o valor que de fato está no pacote. Em vez de passar
+ * calado, `aoLerForaDeUtf8` recebe cada arquivo que não é UTF-8 limpo, para o
+ * deploy avisar que o app vai receber outro valor.
+ *
+ * Rodada final 5: o `--env-file` não é um `.env` que o bundler lê. O
+ * `neetru build` o injeta no ambiente do processo do build, com a regra
+ * própria da CLI (`variaveisDoEnvFile`). Por isso ele entra aqui como ambiente:
+ * vence os arquivos, serve de fonte para a expansão e não é expandido. Cada
+ * valor é procurado como o Next o deixa, como o Vite o deixa e cru.
  */
-export declare function collectPublicEnvSecrets(cwd: string, envFile?: string, processEnv?: NodeJS.ProcessEnv): Promise<PublicEnvSecret[]>;
+export declare function collectPublicEnvSecrets(cwd: string, envFile?: string, processEnv?: NodeJS.ProcessEnv, aoLerForaDeUtf8?: (arquivo: string, problema: ProblemaDeCodificacao) => void): Promise<PublicEnvSecret[]>;
 /**
  * Lê um .tar.gz em streaming e chama `onFile` para cada arquivo regular que
  * `want(nome, tamanho)` aceitar. Arquivos não desejados são pulados sem buffer.