@neetru/cli 2.32.1 → 2.34.0

package/dist/commands/deploy.js

@@ -14,6 +14,8 @@
  *     upload via signed URL — Sprint 2.5).
  *  8. POST /api/cli/v1/deploy → recebe deploymentId + statusUrl.
  *  9. Polling /api/cli/v1/deploy/status até estado terminal.
+ * 10. (VM) Saúde em https://<domain>/api/health?deep=1 e, com ela ok, a
+ *     página inicial: a CSP deixa rodar os scripts embutidos? Só então "Live".
  *
  * NÃO bloqueia em modo `--non-interactive` quando flags suficientes vieram.
  */
@@ -33,15 +35,22 @@ import { DEPLOY_ENVIRONMENT_IDS, deployEnvParaRuntime, } from '../lib/envs.js';
 import { resolveStepUp } from '../lib/cli-write.js';
 import { runBuild } from './build.js';
 import { formatDeployConsole, isDeployUnverified, deployStatusLabel } from './deployments.js';
+import { buildRenderProbeUrl, describeRenderBlock, runRenderProbe, RENDER_BLOCKED_FIX, } from '../lib/deploy-render-probe.js';
 import { readDbJson, schemaFingerprint } from '../lib/db-local/index.js';
 // bug_863ae5: pre-flight IAM check.
 import { assertIamReady } from '../lib/iam-preflight.js';
 import { ALLOW_PUBLIC_SECRET_FLAG, MIN_OVERRIDE_REASON_LENGTH, buildOverrideRecord, collectPublicEnvSecrets, formatFindingsMessage, scanDirectoryForPublicSecrets, scanTarballForPublicSecrets, } from '../lib/public-secret-scan.js';
 import { getActiveTokenSync } from '../lib/token-resolver.js';
 import { BYTES_FAREJADOS, checkDeployTargetContract, farejarConteudoDePacote, mensagemSourceAcimaDoTeto, mensagemSourceNaoEhHandler, pareceArquivoDePacote, WORKSPACE_SOURCE_MAX_BYTES, } from '../lib/deploy-target-contract.js';
+import { AVISO_PORTA_IGNORADA_NA_VM } from '../lib/deploy-vm-um-app.js';
+import { explicarRecusaDeDestino } from '../lib/deploy-recusa-de-destino.js';
 import { safeExit } from '../utils/safe-exit.js';
-import { AVISO_AGENTE_PENDENTE, CHAVES_DO_CARREGADOR, CHAVE_SEGREDO_RE, chaveInjetadaPeloCore, comandoParaRegistrarSegredo, problemaNaChaveReservada, } from '../lib/segredo-produto.js';
+import { CHAVES_DO_CARREGADOR, CHAVE_SEGREDO_RE, chaveInjetadaPeloCore, comandoParaRegistrarSegredo, notaSegredoDescartadoNoDeploy, problemaNaChaveReservada, } from '../lib/segredo-produto.js';
 import { avisoEnvDoBundlerForaDeUtf8, CodificacaoInvalida, decodificarUtf8, semBomInicial, } from '../lib/texto-utf8.js';
+// bug_1dcf8e03: o template de Dockerfile do cloud-run usa a MESMA detecção de
+// gerenciador de pacote do cli#106 (build-targets.ts) pra não supor npm/app
+// único num monorepo pnpm/yarn/bun.
+import { detectPackageManager } from '../lib/build-targets.js';
 /**
  * bug_a5786e03 (2026-05-31): o Core/agente só conhecem os stacks canônicos
  * `node|docker|php-apache|static` (PRODUCT_STACKS). `nextjs` é um alias de
@@ -187,9 +196,16 @@ export async function runPublicSecretGate(source, ctx) {
  * Também não mandamos para stack não-node: ali `entrypoint` é `index.html` /
  * `index.php` / referência de imagem, que não é "arquivo para o `node` rodar".
  *
- * ATENÇÃO — a cadeia ainda NÃO fecha só com isto: o Core descarta o campo hoje
- * (`deployRequestSchema` não o declara, e objeto zod sem `.passthrough()` remove
- * chave desconhecida em silêncio). Ver "o que falta no Core" na descrição do PR.
+ * Do lado do Core o campo chega: desde o d6cfda64 (2026-10-11) o
+ * `deployRequestSchema` declara `entrypoint` e o `entrypointToStartCommand` o
+ * traduz para o `startCommand` do agente (`node apps/web/server.js`).
+ *
+ * O que ainda NÃO fecha é do agente (medido na main dele, 1.6.80): a decisão de
+ * instalar dependências (`resolveNodeInstallPlan` em `deploy-plan.ts`) também
+ * olha só a raiz do pacote. Sem `server.js` nem `.next/` na raiz, o pacote de
+ * monorepo não é reconhecido como standalone e o agente roda `npm rebuild` (e,
+ * se falhar, `npm install`) na raiz do pacote, em vez de pular a instalação.
+ * O conserto é no `neetru-agent-service-vm` (bug_bc72fe7e).
  */
 export function entrypointParaDeploy(manifest) {
     if (!manifest)
@@ -447,15 +463,18 @@ export function avisoSegredoDescartadoNaVm(chave, env) {
             '(letras, dígitos e underscore, começando por letra, de 2 a 64 caracteres). Renomeie a ' +
             `variável no app e registre-a com \`${comandoParaRegistrarSegredo('<NOME>', env)}\`.`);
     }
+    // bug_89d2497e (etapa 1): o "use --generate" solto era lido pelo usuário do
+    // `neetru deploy`, que não declara a flag. O texto cita o comando inteiro.
+    const registrar = comandoParaRegistrarSegredo(chave, env);
     return (inicio +
         'segredo não vai no deploy por variável de ambiente (ficaria gravado no Firestore, que toda ' +
-        `a equipe lê). Registre-o com \`${comandoParaRegistrarSegredo(chave, env)}\` — o valor vai ` +
-        'direto para o Secret Manager; use --generate quando o Core puder sortear o valor.');
+        `a equipe lê). Registre-o com \`${registrar}\` — o valor vai direto para o Secret Manager. ` +
+        `Para o Core sortear o valor, use \`${registrar} --generate\`.`);
 }
 /**
  * O aviso desta chave manda para `neetru secrets set`? Não manda quando o
- * Core reserva a chave — aí o aviso de que o agente ainda não entrega
- * segredos do produto também não cabe.
+ * Core reserva a chave — aí a nota de como o segredo registrado chega ao app
+ * (`notaSegredoDescartadoNoDeploy`) também não cabe.
  */
 export function segredoDescartadoApontaSecretsSet(chave) {
     return problemaNaChaveReservada(chave) === null;
@@ -548,9 +567,11 @@ env) {
         }
         out[k] = v;
     }
-    // Uma vez só, depois da lista: o registro ainda não chega ao app na VM.
+    // Uma vez só, depois da lista: como o segredo descartado chega ao app (pelo
+    // registro, num deploy). Até a 2.33.0 aqui saía que o agente "ainda não
+    // entrega" — falso desde a 1.6.80 (bug_8b85353b, comentário da vistoria 22/10).
     if (descartouSegredoNaVm)
-        lg.warn(AVISO_AGENTE_PENDENTE);
+        lg.info(notaSegredoDescartadoNoDeploy(env));
     return out;
 }
 // handleApiError unificado em ../lib/api-error.js (auditoria qualidade 2026-06-20).
@@ -1170,6 +1191,55 @@ async function probeDeployedHealth(domain) {
     }
     return { finalVerdict: last.verdict, attempts, lastAttempt: last, url };
 }
+/**
+ * bug_0d2e0087 (caso Zelo 22/10): a saúde 200 não prova que a página aparece.
+ * Com a saúde já confirmada, abre `https://<domain>/` e confere se a CSP deixa
+ * rodar os `<script>` embutidos do Next (regra em `lib/deploy-render-probe.ts`,
+ * espelho do portão do Core). Uma tentativa só; nunca lança — o que não deu pra
+ * conferir volta `unverifiable` e não muda o veredito da saúde.
+ */
+async function probeDeployedRender(domain) {
+    const url = buildRenderProbeUrl(domain);
+    if (!url) {
+        return {
+            verdict: 'unverifiable',
+            url: `https://${domain}/`,
+            httpStatus: null,
+            inlineScripts: 0,
+            blockedInlineScripts: 0,
+            blockingDirective: null,
+            reason: 'domínio não forma URL',
+        };
+    }
+    const spinner = ora({ text: `Conferindo se a página inicial renderiza (${url})…`, color: 'blue' }).start();
+    const render = await runRenderProbe(url, {
+        fetchImpl: (u, init) => fetch(u, init),
+        timeoutMs: healthProbeTiming().requestTimeoutMs,
+    });
+    if (render.verdict === 'ok') {
+        spinner.succeed(`Página inicial: nenhum dos ${render.inlineScripts} script(s) embutido(s) bloqueado pela CSP`);
+    }
+    else if (render.verdict === 'inline_scripts_blocked') {
+        spinner.fail(`Página inicial EM BRANCO no navegador: ${describeRenderBlock(render)}`);
+    }
+    else {
+        // Não é falha nem prova: quem chama diz "não conferida" junto do "Live".
+        spinner.stop();
+    }
+    return render;
+}
+/** Resumo da checagem da página que vai no `health.render` do `--json`. */
+function renderJson(render) {
+    return {
+        verdict: render.verdict,
+        url: render.url,
+        httpStatus: render.httpStatus,
+        inlineScripts: render.inlineScripts,
+        blockedInlineScripts: render.blockedInlineScripts,
+        blockingDirective: render.blockingDirective,
+        reason: render.reason,
+    };
+}
 /**
  * Resolve o arquivo de source `.ts` de um deploy workspace. Ordem de busca:
  * `--artifact <arquivo>` → campo `source` do neetru.config.json → candidatos
@@ -1443,32 +1513,208 @@ function getGcloudProject() {
         return null;
     }
 }
+/**
+ * Lockfile CONCRETO na raiz do gerenciador (`pm.rootDir`), se houver.
+ *
+ * `detectPackageManager` não garante que `pm.lockfile` venha preenchido: com
+ * `packageManager` declarado no package.json, ele some do retorno mesmo que um
+ * lockfile físico exista (ver `build-targets.ts`). Aqui checamos o disco direto
+ * — é o que decide `npm ci` vs `npm install` (bug_1dcf8e03: `npm ci` exige
+ * lockfile e falha sem ele; era esse o `npm ci` cego do template antigo).
+ */
+function lockfileConcretoNaRaiz(pm) {
+    const candidatos = {
+        npm: ['package-lock.json', 'npm-shrinkwrap.json'],
+        pnpm: ['pnpm-lock.yaml'],
+        yarn: ['yarn.lock'],
+        bun: ['bun.lockb', 'bun.lock'],
+    };
+    for (const f of candidatos[pm.name]) {
+        if (fileExists(path.join(pm.rootDir, f)))
+            return f;
+    }
+    return null;
+}
+/**
+ * Linhas de setup do gerenciador, ANTES do install — necessárias porque a
+ * imagem `node:22-slim` só traz npm. pnpm/yarn vêm pelo corepack (já embutido
+ * no Node 22, só falta habilitar); bun não tem corepack, então instala pelo
+ * script oficial.
+ */
+function linhasDeSetupDoGerenciador(pm) {
+    switch (pm) {
+        case 'pnpm':
+        case 'yarn':
+            return ['RUN corepack enable'];
+        case 'bun':
+            return [
+                'RUN apt-get update \\',
+                '  && apt-get install -y --no-install-recommends curl unzip ca-certificates \\',
+                '  && curl -fsSL https://bun.sh/install | bash \\',
+                '  && ln -s /root/.bun/bin/bun /usr/local/bin/bun \\',
+                '  && apt-get purge -y curl unzip \\',
+                '  && rm -rf /var/lib/apt/lists/*',
+            ];
+        case 'npm':
+        default:
+            return [];
+    }
+}
+/**
+ * Comando de install SÓ-PRODUÇÃO (`--omit=dev`/`--production`), pro caso de
+ * app único (sem build dentro do Dockerfile — stack=node) e pro `deps` stage
+ * do stack=nextjs de app único (o builder reusa esses node_modules).
+ *
+ * bug_1dcf8e03: sem lockfile, `npm ci`/`--frozen-lockfile` falham de cara —
+ * cai pro install não-travado (mesma régua do `comandoInstall` de
+ * build-targets.ts, adaptada pra Dockerfile: aqui, diferente do build local,
+ * reprodutibilidade é bem-vinda, então com lockfile preferimos ci/frozen).
+ */
+function instalarSoProducao(pm, temLockfile) {
+    switch (pm) {
+        case 'pnpm':
+            return temLockfile ? 'pnpm install --prod --frozen-lockfile' : 'pnpm install --prod --no-frozen-lockfile';
+        case 'yarn':
+            return temLockfile ? 'yarn install --production --frozen-lockfile' : 'yarn install --production';
+        case 'bun':
+            return 'bun install --production';
+        case 'npm':
+        default:
+            return temLockfile ? 'npm ci --omit=dev' : 'npm install --omit=dev';
+    }
+}
+/**
+ * Comando de install COMPLETO (com devDependencies) — usado só no builder do
+ * stack=nextjs em MONOREPO, porque o `next build` roda DENTRO do container e
+ * pode precisar de devDependencies do workspace (typescript, plugins de
+ * build). Sem risco pro tamanho da imagem final: o builder é descartado; o
+ * runner só copia o `.next/standalone` (que já vem só com o necessário em
+ * runtime, tracejado pelo próprio Next.js).
+ */
+function instalarCompleto(pm, temLockfile) {
+    switch (pm) {
+        case 'pnpm':
+            return temLockfile ? 'pnpm install --frozen-lockfile' : 'pnpm install --no-frozen-lockfile';
+        case 'yarn':
+            return temLockfile ? 'yarn install --frozen-lockfile' : 'yarn install';
+        case 'bun':
+            return 'bun install';
+        case 'npm':
+        default:
+            return temLockfile ? 'npm ci' : 'npm install';
+    }
+}
+function comandoDeBuild(pm) {
+    switch (pm) {
+        case 'pnpm':
+            return 'pnpm run build';
+        case 'yarn':
+            return 'yarn run build';
+        case 'bun':
+            return 'bun run build';
+        case 'npm':
+        default:
+            return 'npm run build';
+    }
+}
+/**
+ * Manifests a copiar no estágio `deps` (cache de layer) do caminho de APP
+ * ÚNICO. Só entra o lockfile que REALMENTE existe no disco — listar um que
+ * não existe faz o `COPY` falhar o build inteiro (ao contrário do glob
+ * `package*.json`, que sempre casa com pelo menos um arquivo, porque
+ * `package.json` é garantido).
+ */
+function manifestsParaCache(pmName, lockfileEncontrado) {
+    if (pmName === 'npm')
+        return ['package*.json'];
+    return lockfileEncontrado ? ['package.json', lockfileEncontrado] : ['package.json'];
+}
 /**
  * Gera um Dockerfile temporário para a stack informada e retorna o path do
- * diretório temporário. O caller é responsável por apagar o dir após o uso.
+ * diretório temporário, junto do diretório onde o build deve rodar
+ * (`buildContext`). O caller é responsável por apagar o `tmpDir` após o uso.
  *
  * Fix bug_1904ba55: quando --stack=node|nextjs e Dockerfile ausente, o CLI
  * gera um template adequado em vez de falhar com erro pouco acionável.
+ *
+ * Fix bug_1dcf8e03: o template supunha app único com npm — `npm ci` sem
+ * lockfile (pnpm/yarn/bun não têm package-lock.json) falhava de cara, e em
+ * monorepo o contexto era só o `cwd` (as deps `workspace:*` não resolvem) e o
+ * `CMD`/`COPY` do standalone assumiam `server.js` na RAIZ de `/app`.
+ *
+ * `appDir` é o `cwd` de onde `neetru deploy` roda — a mesma convenção que
+ * `neetru build --app`/`--cwd` usa (build-targets.ts): `detectPackageManager`
+ * sobe a árvore a partir dele até achar o lockfile do workspace (ou o próprio
+ * `appDir`, se for app único). O `relativeAppDir` daí (`path.relative` entre
+ * a raiz do workspace e `appDir`) é o MESMO prefixo que o `next build` usa pra
+ * aninhar o app dentro do `.next/standalone` (`outputFileTracingRoot` por
+ * padrão é a raiz do workspace) — é por isso que o `COPY`/`CMD` do runner
+ * apontam pra `<relativeAppDir>/.next/standalone/<relativeAppDir>/server.js`:
+ * a MESMA regra de aninhamento que `resolveStandaloneLayout` usa pro pacote
+ * da VM (cli#106), só que calculada ANTES do build (o Dockerfile builda do
+ * zero) em vez de lida do `required-server-files.json` depois dele.
+ *
+ * App único (`relativeAppDir === ''`) preserva o shape de hoje (3 estágios
+ * deps/builder/runner com cache de layer) — só o gerenciador muda.
  */
-async function generateDockerfileTemplate(stack, cwd) {
+async function generateDockerfileTemplate(stack, appDir) {
     const os = await import('node:os');
     const tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'neetru-dockerfile-'));
+    const pm = detectPackageManager(appDir);
+    const buildContext = pm.rootDir;
+    const relativeAppDir = path.relative(pm.rootDir, appDir).split(path.sep).join('/');
+    const lockfileEncontrado = lockfileConcretoNaRaiz(pm);
+    const temLockfile = lockfileEncontrado !== null;
+    const setupLinhas = linhasDeSetupDoGerenciador(pm.name);
     let content;
-    if (stack === 'nextjs') {
+    if (stack === 'nextjs' && relativeAppDir) {
+        // ── Monorepo (bug_1dcf8e03): contexto = raiz do workspace, instala tudo
+        // (workspace:* precisa dos outros pacotes), builda dentro do prefixo do
+        // app e o runner copia só o standalone aninhado (padrão igual ao cli#106).
+        content = [
+            `# Dockerfile gerado automaticamente por neetru deploy --stack=nextjs`,
+            `# Monorepo detectado: app em ${relativeAppDir}/, gerenciador ${pm.name} (${pm.source}${lockfileEncontrado ? `: ${lockfileEncontrado}` : ''})`,
+            '# Next.js standalone output (output: "standalone" no next.config.*)',
+            'FROM node:22-slim AS base',
+            'WORKDIR /app',
+            '',
+            'FROM base AS builder',
+            ...setupLinhas,
+            // Contexto inteiro: workspace:* só resolve com o monorepo completo.
+            'COPY . .',
+            `RUN ${instalarCompleto(pm.name, temLockfile)}`,
+            `RUN cd ${relativeAppDir} && ${comandoDeBuild(pm.name)}`,
+            '',
+            'FROM base AS runner',
+            'ENV NODE_ENV=production',
+            'ENV PORT=8080',
+            'ENV HOSTNAME=0.0.0.0',
+            `COPY --from=builder /app/${relativeAppDir}/.next/standalone ./`,
+            `COPY --from=builder /app/${relativeAppDir}/.next/static ./${relativeAppDir}/.next/static`,
+            `COPY --from=builder /app/${relativeAppDir}/public ./${relativeAppDir}/public`,
+            'EXPOSE 8080',
+            `CMD ["node", "${relativeAppDir}/server.js"]`,
+        ].join('\n');
+    }
+    else if (stack === 'nextjs') {
+        const manifests = manifestsParaCache(pm.name, lockfileEncontrado);
         content = [
             '# Dockerfile gerado automaticamente por neetru deploy --stack=nextjs',
+            `# Gerenciador detectado: ${pm.name} (${pm.source}${lockfileEncontrado ? `: ${lockfileEncontrado}` : ''})`,
             '# Next.js standalone output (output: "standalone" no next.config.*)',
             'FROM node:22-slim AS base',
             'WORKDIR /app',
             '',
             'FROM base AS deps',
-            'COPY package*.json ./',
-            'RUN npm ci --omit=dev',
+            ...setupLinhas,
+            `COPY ${manifests.join(' ')} ./`,
+            `RUN ${instalarSoProducao(pm.name, temLockfile)}`,
             '',
             'FROM base AS builder',
+            ...setupLinhas,
             'COPY --from=deps /app/node_modules ./node_modules',
             'COPY . .',
-            'RUN npm run build',
+            `RUN ${comandoDeBuild(pm.name)}`,
             '',
             'FROM base AS runner',
             'ENV NODE_ENV=production',
@@ -1481,14 +1727,31 @@ async function generateDockerfileTemplate(stack, cwd) {
             'CMD ["node", "server.js"]',
         ].join('\n');
     }
+    else if (relativeAppDir) {
+        // stack === 'node', monorepo: sem passo de build — o server.js já vem
+        // pronto no repositório; só precisa do workspace inteiro instalado.
+        content = [
+            '# Dockerfile gerado automaticamente por neetru deploy --stack=node',
+            `# Monorepo detectado: app em ${relativeAppDir}/, gerenciador ${pm.name} (${pm.source}${lockfileEncontrado ? `: ${lockfileEncontrado}` : ''})`,
+            'FROM node:22-slim',
+            'WORKDIR /app',
+            ...setupLinhas,
+            'COPY . .',
+            `RUN ${instalarSoProducao(pm.name, temLockfile)}`,
+            'EXPOSE 8080',
+            `CMD ["node", "${relativeAppDir}/server.js"]`,
+        ].join('\n');
+    }
     else {
-        // stack === 'node'
+        // stack === 'node', app único (caso de hoje — não muda)
+        const manifests = manifestsParaCache(pm.name, lockfileEncontrado);
         content = [
             '# Dockerfile gerado automaticamente por neetru deploy --stack=node',
             'FROM node:22-slim',
             'WORKDIR /app',
-            'COPY package*.json ./',
-            'RUN npm ci --omit=dev',
+            ...setupLinhas,
+            `COPY ${manifests.join(' ')} ./`,
+            `RUN ${instalarSoProducao(pm.name, temLockfile)}`,
             'COPY . .',
             'EXPOSE 8080',
             'CMD ["node", "server.js"]',
@@ -1498,8 +1761,8 @@ async function generateDockerfileTemplate(stack, cwd) {
     await fsp.writeFile(dockerfilePath, content, 'utf8');
     // Copia o contexto do projeto para o tmpDir para permitir gcloud builds submit
     // usando --source=cwd mas com Dockerfile injetado.
-    // Na prática copiamos só o Dockerfile; gcloud usa --source=cwd separado.
-    return { tmpDir, dockerfilePath };
+    // Na prática copiamos só o Dockerfile; gcloud usa --source=<buildContext> separado.
+    return { tmpDir, dockerfilePath, buildContext };
 }
 /**
  * Constrói a URI completa do Artifact Registry a partir das opções fornecidas.
@@ -1587,22 +1850,27 @@ async function resolveCloudRunImage(opts, productSlug, envName, cwd) {
         if (stack === 'node' || stack === 'nextjs') {
             lg.warn(`Dockerfile não encontrado em ${cwd}.\n` +
                 `  Gerando template automático para --stack=${stack}…`);
-            const { tmpDir, dockerfilePath } = await generateDockerfileTemplate(stack, cwd);
+            // bug_1dcf8e03: em monorepo, o build context tem que ser a RAIZ do
+            // workspace (onde mora o lockfile) — é lá que o Dockerfile gerado
+            // também é escrito, porque `gcloud builds submit`/`docker build`
+            // procuram o `Dockerfile` na raiz do próprio contexto.
+            const { tmpDir, dockerfilePath, buildContext: generatedBuildContext } = await generateDockerfileTemplate(stack, cwd);
             generatedDockerfileDir = tmpDir;
-            // Copia o Dockerfile gerado para o cwd temporariamente usando flag 'wx'
-            // (exclusive create) para evitar sobrescrever um Dockerfile que possa ter
-            // aparecido entre o check fileExists() acima e agora (race condition).
-            const destDockerfile = path.join(cwd, 'Dockerfile');
+            buildContext = generatedBuildContext;
+            // Copia o Dockerfile gerado pro build context temporariamente usando flag
+            // 'wx' (exclusive create) para evitar sobrescrever um Dockerfile que possa
+            // ter aparecido entre o check fileExists() acima e agora (race condition).
+            const destDockerfile = path.join(buildContext, 'Dockerfile');
             try {
                 const content = await fsp.readFile(dockerfilePath, 'utf8');
                 await fsp.writeFile(destDockerfile, content, { flag: 'wx' });
-                lg.dim(`  Dockerfile temporário gerado em ${cwd}/Dockerfile`);
+                lg.dim(`  Dockerfile temporário gerado em ${buildContext}/Dockerfile`);
             }
             catch (err) {
                 if (err.code === 'EEXIST') {
                     // Outro processo criou um Dockerfile no intervalo assíncrono — usar o
                     // existente sem sobrescrever; não marcar como gerado (não apagar no finally).
-                    lg.warn(`Dockerfile encontrado em ${cwd} (criado durante geração automática). Usando o existente.`);
+                    lg.warn(`Dockerfile encontrado em ${buildContext} (criado durante geração automática). Usando o existente.`);
                     generatedDockerfileDir = null; // não remover no finally
                 }
                 else {
@@ -1676,7 +1944,10 @@ async function resolveCloudRunImage(opts, productSlug, envName, cwd) {
     finally {
         // ── Limpa Dockerfile temporário gerado ────────────────────────────────────
         if (generatedDockerfileDir) {
-            const tmpDockerfile = path.join(cwd, 'Dockerfile');
+            // bug_1dcf8e03: o Dockerfile foi escrito em `buildContext` (raiz do
+            // workspace em monorepo), não necessariamente em `cwd` — limpa do
+            // mesmo lugar onde foi gravado.
+            const tmpDockerfile = path.join(buildContext, 'Dockerfile');
             try {
                 await fsp.rm(tmpDockerfile, { force: true });
                 await fsp.rm(generatedDockerfileDir, { recursive: true, force: true });
@@ -1760,7 +2031,9 @@ envFileTexto) {
     }
     catch (err) {
         spinner.fail('Falha ao publicar.');
-        handleApiError(err, opts.json);
+        // bug_6d92ef71 / bug_fe30f035: recusa "ambiente tem destino X" explicada
+        // (ver `lib/deploy-recusa-de-destino.ts`); qualquer outro erro passa intacto.
+        handleApiError(explicarRecusaDeDestino(err, productSlug), opts.json);
     }
     if (resp.status === 'live') {
         spinner.succeed(`Deploy ${chalk.bold('live')} · ${resp.deploymentId}`);
@@ -2019,6 +2292,34 @@ export async function runDeploy(opts) {
         await runCloudRunDeploy(opts, productSlug, (opts.env ?? 'dev').toLowerCase(), cwd, nonInteractive, envFileTexto);
         return;
     }
+    // P6 (2026-07-19): a porta interna do app deixou de ser exigida em deploy
+    // VM — o Core/agente aloca por (produto,env,VM). bug_a9c0bc3 (HIGH, 27/05)
+    // motivou o guard antigo (Core rejeitava sem --port); o Core agora ignora
+    // porta em deploy VM, então exigi-la aqui só atrapalharia scripts/CI.
+    // --port continua aceito (compat) mas é ignorado com aviso.
+    //
+    // bug_6d92ef71 (low), 1ª metade: o `!opts.json` calava o aviso POR COMPLETO
+    // em modo machine-readable. Em --json o aviso vai pro stderr (fora do
+    // contrato de 1 linha JSON do stdout); no modo humano, `log.warn`.
+    //
+    // bug_6d92ef71, 2ª metade (vistoria de 22/10): o aviso confirmava a
+    // limitação e não dava saída. Quem passa --port na VM quase sempre quer um
+    // SEGUNDO app do mesmo produto — e um 2º deploy do mesmo produto e ambiente
+    // SUBSTITUI o primeiro (o Core reconhece o app por produto+ambiente). O texto
+    // agora diz isso e o caminho que existe (ver `lib/deploy-vm-um-app.ts`).
+    //
+    // Roda ANTES do `pickServer` (NIT da mesma vistoria): num `--json
+    // --non-interactive` sem `--server`, a CLI morria em `server_required`
+    // antes de avisar. E `!== undefined`: `--port abc` vira NaN e também é
+    // descartado na VM, então também avisa.
+    if (target === 'vm' && opts.port !== undefined) {
+        if (opts.json) {
+            console.error(AVISO_PORTA_IGNORADA_NA_VM);
+        }
+        else {
+            log.warn(AVISO_PORTA_IGNORADA_NA_VM);
+        }
+    }
     // F-11: env name pra GCS path (`gs://neetru-deploy-artifacts/<product>/<env>/…`).
     // Default 'dev' quando não definido — alinhado com o middleware OAuth.
     const envName = (opts.env ?? 'dev').toLowerCase();
@@ -2036,29 +2337,6 @@ export async function runDeploy(opts) {
         serverChoice = await pickServer(opts, nonInteractive);
     }
     // target='workspace' não exige server — backend resolve runtime per-tenant.
-    // P6 (2026-07-19): a porta interna do app deixou de ser exigida em deploy
-    // VM — o Core/agente aloca por (produto,env,VM). bug_a9c0bc3 (HIGH, 27/05)
-    // motivou o guard antigo (Core rejeitava sem --port); o Core agora ignora
-    // porta em deploy VM, então exigi-la aqui só atrapalharia scripts/CI.
-    // --port continua aceito (compat) mas é ignorado com WARN — ver abaixo.
-    //
-    // bug_6d92ef71 (low): o `!opts.json` calava o aviso POR COMPLETO em modo
-    // machine-readable — nem no stdout (certo, quebraria o contrato de 1 linha
-    // JSON do --json), nem em canal nenhum. Quem roda via script nunca
-    // descobria que --port foi descartado. Mantém o aviso humano em stdout no
-    // modo interativo e manda a MESMA informação pro stderr em --json — stderr
-    // não faz parte do contrato de saída parseável, então não quebra nada.
-    // Mensagem também deixou de dizer "staging/prod": o guard dispara pra
-    // QUALQUER ambiente em target=vm (inclusive dev).
-    if (target === 'vm' && opts.port) {
-        const portIgnoredMsg = 'A porta é gerenciada pelo Core em deploy VM (aloca por produto/ambiente/servidor); --port é ignorado.';
-        if (opts.json) {
-            console.error(portIgnoredMsg);
-        }
-        else {
-            log.warn(portIgnoredMsg);
-        }
-    }
     const { domain } = await pickDomain(opts, nonInteractive, productSlug);
     // Build / artifact (default: faz upload pra GCS via signed URL).
     const artifact = await resolveArtifact(opts, productSlug, envName, cwd);
@@ -2122,7 +2400,7 @@ export async function runDeploy(opts) {
     };
     // bug_678ddc98: standalone aninhado de monorepo — o agente não tem como
     // inferir `apps/web/server.js` olhando a raiz do tarball. Ver
-    // `entrypointParaDeploy` (e, no PR, o que ainda falta do lado do Core).
+    // `entrypointParaDeploy` (e, lá, o que ainda falta do lado do agente).
     const entrypointAninhado = entrypointParaDeploy(artifact.manifest);
     if (entrypointAninhado) {
         body.entrypoint = entrypointAninhado;
@@ -2157,7 +2435,12 @@ export async function runDeploy(opts) {
     }
     catch (err) {
         dispatchSpinner.fail('Falha ao criar deploy.');
-        handleApiError(err, opts.json);
+        // bug_6d92ef71 / bug_fe30f035: o produto novo (o caminho "dois apps = dois
+        // produtos") nasce com os ambientes no destino workspace, e o Core recusa o
+        // 1º deploy na VM com um conselho que a CLI não tem como seguir. A recusa
+        // sai explicada (ver `lib/deploy-recusa-de-destino.ts`); qualquer outro erro
+        // passa intacto.
+        handleApiError(explicarRecusaDeDestino(err, productSlug), opts.json);
     }
     const final = await pollDeploymentStatus(deploy.deploymentId, opts.json);
     if (final.status !== 'success') {
@@ -2226,6 +2509,40 @@ export async function runDeploy(opts) {
     }
     const probe = await probeDeployedHealth(final.domain);
     if (probe.finalVerdict === 'healthy') {
+        // bug_0d2e0087 (caso Zelo 22/10): health 200 com JSON saudável e a página
+        // inicial EM BRANCO — a CSP do produto bloqueava os <script> embutidos do
+        // Next. O `deploy/status` do Core diz só que o DEPLOYMENT terminou; quem
+        // confere a página no Core é o gatilho das functions (core#793), depois,
+        // e o resultado dele não volta por essa rota. Então a CLI confere aqui
+        // antes de afirmar "Live".
+        const render = await probeDeployedRender(final.domain);
+        if (render.verdict === 'inline_scripts_blocked') {
+            const blockDetail = describeRenderBlock(render);
+            const renderMsg = `Deploy aceito pelo Core e a saúde passou, mas a página inicial fica EM BRANCO no navegador: ` +
+                `${blockDetail}.`;
+            if (opts.json) {
+                console.log(JSON.stringify({
+                    ...base,
+                    ok: false,
+                    error: 'render_blocked',
+                    message: `${renderMsg} ${RENDER_BLOCKED_FIX}`,
+                    health: {
+                        verified: false,
+                        verdict: 'render_blocked',
+                        httpStatus: probe.lastAttempt.httpStatus ?? null,
+                        attempts: probe.attempts,
+                        url: probe.url,
+                        detail: blockDetail,
+                        render: renderJson(render),
+                    },
+                }));
+            }
+            else {
+                log.error(renderMsg);
+                log.warn(`Não marcando como "Live". ${RENDER_BLOCKED_FIX}`);
+            }
+            safeExit(1);
+        }
         if (opts.json) {
             console.log(JSON.stringify({
                 ...base,
@@ -2235,11 +2552,15 @@ export async function runDeploy(opts) {
                     httpStatus: probe.lastAttempt.httpStatus ?? null,
                     attempts: probe.attempts,
                     url: probe.url,
+                    render: renderJson(render),
                 },
             }));
         }
         else {
             log.success(`Live em https://${final.domain}`);
+            if (render.verdict === 'unverifiable') {
+                log.dim(`  página inicial não conferida (${render.reason ?? 'motivo desconhecido'}) — vale abrir no navegador.`);
+            }
         }
         safeExit(0);
     }

package/dist/commands/dev-context.js

@@ -72,7 +72,7 @@ function mergeDevDatabases(current, productId, databases) {
 async function resolveProductForSync(token, opts) {
     const explicit = opts.productId ?? opts.product ?? opts.context?.productId ?? opts.context?.productSlug;
     if (!explicit) {
-        log.error('Produto não definido. Use `neetru dev use --product <slug-ou-id>` ou `--prototype <slug>`.');
+        log.error('Produto não definido. Use `neetru dev use --product <slug-ou-id>` ou `neetru dev use --prototype <slug>`.');
         safeExit(1);
     }
     const productId = opts.productId ?? await resolveProductIdentifier(token, explicit);