@neetru/cli 2.33.0 → 2.34.0

package/dist/lib/deploy-render-probe.js

@@ -0,0 +1,475 @@
+/**
+ * deploy-render-probe.ts — a página inicial do produto RENDERIZA no navegador?
+ * (bug_0d2e0087, lado da CLI).
+ *
+ * DEFEITO (caso Zelo, 22/10): `neetru deploy --target vm` imprimia "Live em
+ * https://zelo.neetru.com" com `health.verified:true`, e a página ficava EM
+ * BRANCO para todo visitante. O `next.config` do produto mandava
+ * `Content-Security-Policy: ... script-src 'self'` (sem `'unsafe-inline'`, sem
+ * nonce). O App Router do Next põe o payload RSC em `<script>` embutidos
+ * (`self.__next_f.push(...)`); o navegador bloqueia todos, a hidratação falha
+ * na raiz e o React 19 desmonta a árvore. A CLI não tinha como ver:
+ *  - `GET /api/cli/v1/deploy/status` devolve o status do DEPLOYMENT (`success`),
+ *    não o do ambiente;
+ *  - a sonda de saúde da CLI (`probeDeployedHealth`) lê só o JSON de
+ *    `/api/health`, que respondia 200 saudável.
+ *
+ * O QUE ESTE MÓDULO FAZ: depois que a saúde PASSA, a CLI abre a página inicial
+ * (`https://<domínio>/`), lê as políticas CSP que valem (cabeçalho
+ * `Content-Security-Policy`, o mesmo que o navegador recebe, e
+ * `<meta http-equiv>`) e confere, script embutido por script embutido, se a
+ * política deixa ele rodar (nonce, hash ou `'unsafe-inline'` — este último
+ * ignorado quando há nonce/hash/`'strict-dynamic'`, como no navegador). Algum
+ * bloqueado → `inline_scripts_blocked`, e o deploy NÃO sai como "Live".
+ *
+ * SÓ ACUSA O QUE MEDIU: página que não é HTML 2xx, rede caída, redirect pra
+ * outra origem → `unverifiable`, e o veredito da saúde fica como estava.
+ * `Content-Security-Policy-Report-Only` não bloqueia nada no navegador, então
+ * não conta.
+ *
+ * ESPELHO: a regra é a mesma de `functions/src/lib/deploy-render-probe.ts` do
+ * Core (core#793), que roda no portão de saúde das functions — mas ele roda
+ * DEPOIS do `success` do deployment, num gatilho assíncrono, e grava o
+ * resultado no ambiente, que a rota que a CLI consulta não devolve. Por isso a
+ * CLI confere por conta própria: não depende de deploy do Core nem das
+ * functions. Divergiu do Core? Corrija nos dois.
+ *
+ * Classificação e análise são PURAS; o `fetch` entra injetado em
+ * `runRenderProbe` (o deploy passa o `fetch` global).
+ */
+import { createHash } from 'node:crypto';
+/** Teto de bytes lidos do HTML (os scripts do Next aparecem já no começo do body). */
+export const RENDER_BODY_MAX_BYTES = 512 * 1024;
+/** Redirects seguidos dentro da MESMA origem (ex.: `/` → `/pt-BR`). */
+export const RENDER_MAX_REDIRECTS = 2;
+/** Teto do texto da diretiva guardada no resultado. */
+const DIRECTIVE_MAX_CHARS = 200;
+/**
+ * Lê UMA política serializada (`a b; c d`). Diretiva repetida: vale a primeira
+ * (CSP3 §2.2.1). Nome de diretiva inválido é ignorado. PURA.
+ */
+export function parseCspPolicy(text) {
+    const directives = new Map();
+    for (const part of text.split(';')) {
+        const tokens = part.trim().split(/[\t\n\f\r ]+/).filter(Boolean);
+        if (tokens.length === 0)
+            continue;
+        const name = tokens[0].toLowerCase();
+        if (!/^[a-z0-9-]+$/.test(name))
+            continue;
+        if (directives.has(name))
+            continue;
+        directives.set(name, tokens.slice(1));
+    }
+    return { directives };
+}
+/**
+ * Lê o valor de um cabeçalho `Content-Security-Policy`: várias políticas vêm
+ * separadas por vírgula (cabeçalhos repetidos também chegam assim, juntados
+ * pelo fetch). Política vazia é descartada. PURA.
+ */
+export function parseCspHeader(value) {
+    return value
+        .split(',')
+        .map((p) => parseCspPolicy(p))
+        .filter((p) => p.directives.size > 0);
+}
+/**
+ * Lista de fontes que governa um `<script>` embutido: `script-src-elem`, senão
+ * `script-src`, senão `default-src`. `undefined` = a política não restringe
+ * script. PURA.
+ */
+export function scriptElementSources(policy) {
+    for (const name of ['script-src-elem', 'script-src', 'default-src']) {
+        const sources = policy.directives.get(name);
+        if (sources)
+            return { name, sources };
+    }
+    return undefined;
+}
+/** Normaliza base64/base64url pra comparar hash (`-`→`+`, `_`→`/`, sem `=`). */
+function normB64(v) {
+    return v.replace(/-/g, '+').replace(/_/g, '/').replace(/=+$/, '');
+}
+/**
+ * Este `<script>` embutido roda sob esta lista de fontes? Regras do navegador
+ * (CSP3 "Does element match source list for type and source"):
+ *  - nonce do elemento igual a um `'nonce-…'` da lista → roda;
+ *  - hash do conteúdo igual a um `'sha256|384|512-…'` → roda;
+ *  - `'unsafe-inline'` → roda, MAS só se a lista não tem nonce, hash nem
+ *    `'strict-dynamic'` (com qualquer um deles o navegador ignora o unsafe-inline);
+ *  - o resto (`'self'`, hosts, `'none'`, lista vazia) NÃO libera script embutido.
+ * PURA.
+ */
+export function inlineScriptAllowed(script, sources) {
+    let hasNonceOrHash = false;
+    let unsafeInline = false;
+    let strictDynamic = false;
+    for (const raw of sources) {
+        const lower = raw.toLowerCase();
+        if (lower === "'unsafe-inline'") {
+            unsafeInline = true;
+            continue;
+        }
+        if (lower === "'strict-dynamic'") {
+            strictDynamic = true;
+            continue;
+        }
+        const nonce = /^'nonce-([^']+)'$/i.exec(raw);
+        if (nonce) {
+            hasNonceOrHash = true;
+            if (script.nonce !== null && script.nonce === nonce[1])
+                return true;
+            continue;
+        }
+        const hash = /^'(sha256|sha384|sha512)-([^']+)'$/i.exec(raw);
+        if (hash) {
+            hasNonceOrHash = true;
+            const digest = createHash(hash[1].toLowerCase()).update(script.content, 'utf8').digest('base64');
+            if (normB64(digest) === normB64(hash[2]))
+                return true;
+        }
+    }
+    return unsafeInline && !hasNonceOrHash && !strictDynamic;
+}
+// ─── HTML ────────────────────────────────────────────────────────────────────
+function decodeEntities(v) {
+    return v.replace(/&(#x[0-9a-f]+|#\d+|quot|apos|amp|lt|gt);/gi, (m, code) => {
+        const c = code.toLowerCase();
+        if (c === 'quot')
+            return '"';
+        if (c === 'apos')
+            return "'";
+        if (c === 'amp')
+            return '&';
+        if (c === 'lt')
+            return '<';
+        if (c === 'gt')
+            return '>';
+        const n = c.startsWith('#x') ? parseInt(c.slice(2), 16) : parseInt(c.slice(1), 10);
+        return Number.isFinite(n) && n >= 0 && n <= 0x10ffff ? String.fromCodePoint(n) : m;
+    });
+}
+/** Atributos de uma tag (nome minúsculo → valor decodificado; sem valor → ''). */
+function parseAttributes(attrText) {
+    const attrs = new Map();
+    const re = /([^\s"'<>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+    let m;
+    while ((m = re.exec(attrText)) !== null) {
+        const name = m[1].toLowerCase();
+        if (attrs.has(name))
+            continue;
+        attrs.set(name, decodeEntities(m[2] ?? m[3] ?? m[4] ?? ''));
+    }
+    return attrs;
+}
+/** MIME de JavaScript (HTML "JavaScript MIME type essence match"). */
+const JS_MIME_ESSENCES = new Set([
+    'application/ecmascript',
+    'application/javascript',
+    'application/x-ecmascript',
+    'application/x-javascript',
+    'text/ecmascript',
+    'text/javascript',
+    'text/javascript1.0',
+    'text/javascript1.1',
+    'text/javascript1.2',
+    'text/javascript1.3',
+    'text/javascript1.4',
+    'text/javascript1.5',
+    'text/jscript',
+    'text/livescript',
+    'text/x-ecmascript',
+    'text/x-javascript',
+]);
+/**
+ * O `type` deste `<script>` é executado (e por isso passa pela CSP)? Sem type,
+ * MIME de JS, `module` ou `importmap` → sim. `application/json`,
+ * `application/ld+json` e afins são blocos de dados: o navegador não executa
+ * nem confere na CSP. PURA.
+ */
+function isExecutableScriptType(type) {
+    if (type === undefined)
+        return true;
+    const t = type.trim().toLowerCase();
+    if (t === '' || t === 'module' || t === 'importmap')
+        return true;
+    return JS_MIME_ESSENCES.has(t.split(';')[0].trim());
+}
+/** Scripts embutidos executáveis do HTML (sem `src`, conteúdo não vazio). PURA. */
+export function extractInlineScripts(html) {
+    const noComments = html.replace(/<!--[\s\S]*?-->/g, '');
+    const out = [];
+    const re = /<script\b([^>]*)>([\s\S]*?)<\/script\s*>/gi;
+    let m;
+    while ((m = re.exec(noComments)) !== null) {
+        const attrs = parseAttributes(m[1]);
+        if (attrs.has('src'))
+            continue;
+        if (!isExecutableScriptType(attrs.get('type')))
+            continue;
+        const content = m[2];
+        if (content.trim() === '')
+            continue;
+        out.push({ nonce: attrs.has('nonce') ? attrs.get('nonce') : null, content });
+    }
+    return out;
+}
+/** Políticas de `<meta http-equiv="Content-Security-Policy" content="…">`. PURA. */
+export function extractMetaCspPolicies(html) {
+    const noComments = html.replace(/<!--[\s\S]*?-->/g, '');
+    const out = [];
+    const re = /<meta\b([^>]*)>/gi;
+    let m;
+    while ((m = re.exec(noComments)) !== null) {
+        const attrs = parseAttributes(m[1]);
+        if ((attrs.get('http-equiv') ?? '').trim().toLowerCase() !== 'content-security-policy')
+            continue;
+        const content = attrs.get('content');
+        if (!content)
+            continue;
+        // Meta traz UMA política (CSP3 §3.3): vírgula não separa políticas aqui.
+        const policy = parseCspPolicy(content);
+        if (policy.directives.size > 0)
+            out.push(policy);
+    }
+    return out;
+}
+/**
+ * Quantos scripts embutidos a CSP efetiva bloqueia. Um script só roda se TODAS
+ * as políticas em vigor (cabeçalhos + meta) deixarem. PURA.
+ */
+export function analyzeInlineScriptCsp(input) {
+    const policies = [
+        ...input.cspHeaderValues.flatMap((v) => parseCspHeader(v)),
+        ...extractMetaCspPolicies(input.html),
+    ];
+    const scripts = extractInlineScripts(input.html);
+    let blocked = 0;
+    let blockingDirective = null;
+    for (const script of scripts) {
+        for (const policy of policies) {
+            const governing = scriptElementSources(policy);
+            if (!governing)
+                continue;
+            if (inlineScriptAllowed(script, governing.sources))
+                continue;
+            blocked += 1;
+            if (blockingDirective === null) {
+                const text = [governing.name, ...governing.sources].join(' ');
+                blockingDirective =
+                    text.length > DIRECTIVE_MAX_CHARS ? `${text.slice(0, DIRECTIVE_MAX_CHARS)}…` : text;
+            }
+            break;
+        }
+    }
+    return { inlineScripts: scripts.length, blockedInlineScripts: blocked, blockingDirective };
+}
+function looksLikeHtml(contentType, body) {
+    if (contentType) {
+        const essence = contentType.split(';')[0].trim().toLowerCase();
+        return essence === 'text/html' || essence === 'application/xhtml+xml';
+    }
+    return /^\s*(<!doctype html|<html[\s>])/i.test(body);
+}
+function unverifiable(url, httpStatus, reason) {
+    return {
+        verdict: 'unverifiable',
+        url,
+        httpStatus,
+        inlineScripts: 0,
+        blockedInlineScripts: 0,
+        blockingDirective: null,
+        reason,
+    };
+}
+/**
+ * Classifica a resposta da página inicial. PURA.
+ *  - rede/não-2xx/não-HTML → `unverifiable` (não é prova de nada);
+ *  - HTML com script embutido que a CSP bloqueia → `inline_scripts_blocked`;
+ *  - o resto (sem CSP, CSP que libera, sem script embutido) → `ok`.
+ */
+export function classifyRenderProbe(url, input) {
+    if (input.kind === 'network_error')
+        return unverifiable(url, null, input.error);
+    const { httpStatus } = input;
+    if (httpStatus < 200 || httpStatus >= 300)
+        return unverifiable(url, httpStatus, `HTTP ${httpStatus}`);
+    if (!looksLikeHtml(input.contentType, input.html)) {
+        return unverifiable(url, httpStatus, `não é HTML (${input.contentType ?? 'sem content-type'})`);
+    }
+    const analysis = analyzeInlineScriptCsp({ cspHeaderValues: input.cspHeaderValues, html: input.html });
+    return {
+        verdict: analysis.blockedInlineScripts > 0 ? 'inline_scripts_blocked' : 'ok',
+        url,
+        httpStatus,
+        inlineScripts: analysis.inlineScripts,
+        blockedInlineScripts: analysis.blockedInlineScripts,
+        blockingDirective: analysis.blockingDirective,
+        reason: null,
+    };
+}
+// ─── I/O (injetado) ──────────────────────────────────────────────────────────
+/**
+ * Lê o corpo até `maxBytes` (cancela o stream acima disso). Mesmo leitor do
+ * Core (`readBodyTextCapped`). Lança se o stream falhar — quem chama trata.
+ */
+async function readBodyTextCapped(body, maxBytes) {
+    if (!body)
+        return '';
+    const reader = body.getReader();
+    const parts = [];
+    let total = 0;
+    let truncated = false;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (!value || value.byteLength === 0)
+                continue;
+            const room = maxBytes - total;
+            if (value.byteLength > room) {
+                if (room > 0)
+                    parts.push(value.subarray(0, room));
+                total += Math.max(0, room);
+                truncated = true;
+                break;
+            }
+            parts.push(value);
+            total += value.byteLength;
+        }
+    }
+    finally {
+        if (truncated) {
+            try {
+                await reader.cancel();
+            }
+            catch {
+                // stream já encerrado — nada a fazer
+            }
+        }
+    }
+    const joined = new Uint8Array(total);
+    let offset = 0;
+    for (const part of parts) {
+        joined.set(part, offset);
+        offset += part.byteLength;
+    }
+    return new TextDecoder().decode(joined);
+}
+/** URL da página inicial do domínio publicado. `null` se o domínio não forma URL. PURA. */
+export function buildRenderProbeUrl(domain) {
+    try {
+        const u = new URL(`https://${domain}/`);
+        return `${u.origin}/`;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Abre a página inicial e classifica. Uma tentativa por salto (a saúde acabou
+ * de passar — não é hora de esperar app subir). `redirect:'manual'`: segue no
+ * máximo `RENDER_MAX_REDIRECTS` saltos e só na MESMA origem; redirect pra fora
+ * (login de terceiro, outro host) → `unverifiable`. Nunca lança.
+ */
+export async function runRenderProbe(url, deps) {
+    const maxRedirects = deps.maxRedirects ?? RENDER_MAX_REDIRECTS;
+    let current = url;
+    const origin = (() => {
+        try {
+            return new URL(url).origin;
+        }
+        catch {
+            return null;
+        }
+    })();
+    if (!origin)
+        return unverifiable(url, null, 'URL inválida');
+    for (let hop = 0; hop <= maxRedirects; hop += 1) {
+        // `null` = este salto foi redirect (segue em `location`).
+        let input = null;
+        let location = null;
+        try {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), deps.timeoutMs);
+            try {
+                const res = await deps.fetchImpl(current, {
+                    method: 'GET',
+                    redirect: 'manual',
+                    signal: controller.signal,
+                    headers: {
+                        'cache-control': 'no-cache',
+                        accept: 'text/html,application/xhtml+xml',
+                    },
+                });
+                if (!res || typeof res.status !== 'number') {
+                    return unverifiable(current, null, 'resposta vazia');
+                }
+                if (res.status >= 300 && res.status < 400) {
+                    location = res.headers.get('location');
+                    try {
+                        await res.body?.cancel();
+                    }
+                    catch {
+                        // corpo já fechado
+                    }
+                    if (!location)
+                        return unverifiable(current, res.status, `HTTP ${res.status} sem Location`);
+                }
+                else {
+                    const csp = res.headers.get('content-security-policy');
+                    const html = await readBodyTextCapped(res.body, RENDER_BODY_MAX_BYTES);
+                    input = {
+                        kind: 'response',
+                        httpStatus: res.status,
+                        contentType: res.headers.get('content-type'),
+                        cspHeaderValues: csp ? [csp] : [],
+                        html,
+                    };
+                }
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return classifyRenderProbe(current, {
+                kind: 'network_error',
+                error: msg.toLowerCase().includes('abort') ? `timeout após ${deps.timeoutMs}ms` : msg,
+            });
+        }
+        if (input !== null)
+            return classifyRenderProbe(current, input);
+        if (location === null)
+            return unverifiable(current, null, 'resposta sem corpo nem Location');
+        let next;
+        try {
+            next = new URL(location, current);
+        }
+        catch {
+            return unverifiable(current, null, 'Location inválido');
+        }
+        if (next.origin !== origin)
+            return unverifiable(current, null, `redirect para outra origem (${next.origin})`);
+        current = next.toString();
+    }
+    return unverifiable(current, null, `mais de ${maxRedirects} redirects`);
+}
+// ─── texto ───────────────────────────────────────────────────────────────────
+/** O que foi bloqueado, em uma frase (vai no `detail` do JSON e na tela). PURA. */
+export function describeRenderBlock(render) {
+    return (`${render.blockedInlineScripts} de ${render.inlineScripts} script(s) embutido(s) da página ` +
+        `${render.url} bloqueado(s) pela Content-Security-Policy` +
+        (render.blockingDirective ? ` (${render.blockingDirective})` : ''));
+}
+/**
+ * O efeito e onde se conserta — mesma frase do alerta do Core
+ * (`renderBlockedExplanation`), sem o prefixo da saúde. PURA.
+ */
+export const RENDER_BLOCKED_FIX = 'Sem esses scripts o Next não hidrata e a tela some para todo visitante. ' +
+    'Conserto no produto: no cabeçalho Content-Security-Policy (next.config, headers()), o script-src ' +
+    "precisa de nonce por requisição (recomendado) ou 'unsafe-inline'.";
+//# sourceMappingURL=deploy-render-probe.js.map

package/dist/lib/deploy-vm-um-app.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Deploy na VM: um app por produto e ambiente — o que a CLI diz ao dev.
+ *
+ * ORIGEM — bug_6d92ef71. A descrição tinha duas metades:
+ *
+ *  1. `neetru deploy --target vm --port 3001` descartava a porta sem avisar.
+ *     Consertado antes (P6, f3a9611, d327d30): a CLI avisa que o Core escolhe
+ *     a porta.
+ *  2. "não fica claro como subir dois processos do mesmo produto (ex.: web e
+ *     API em subdomínios diferentes) na mesma VM: dois deploys --product=X
+ *     --env prod provavelmente se substituem."
+ *
+ * A metade 2 foi MEDIDA no Core (vistoria de 22/10) e é verdadeira:
+ *  - `appKeyOf(productId, environmentId)` (src/lib/ports/port-registry.ts) é a
+ *    identidade do app na VM — produto + ambiente, nada mais;
+ *  - `ensureStableProxyPort` (src/lib/actions/_vm-deploy-core.ts) reusa a
+ *    MESMA porta para o mesmo par, e o deploy novo troca o app que está nela;
+ *  - `syncEnvironmentSubdomainPortCore` (src/lib/actions/_product-subdomains-cores.ts)
+ *    guarda UM endereço por (produto, ambiente) e o aponta para a porta e o
+ *    servidor do último deploy;
+ *  - o deploy da CLI não tem flag para nomear um segundo app do mesmo produto.
+ *
+ * O aviso do conserto 1 confirmava a limitação e não dava saída: quem passa
+ * `--port` quase sempre quer subir um SEGUNDO app, e depois do aviso seguia
+ * sem caminho. Aqui fica a resposta, escrita uma vez e usada nos dois lugares
+ * onde o dev a encontra: o aviso do `--port` (`runDeploy`) e a ajuda do
+ * `neetru deploy --help` (`index.ts`).
+ *
+ * O caminho que existe hoje, medido no Core:
+ *  - dois apps = dois produtos. `POST /api/cli/v1/products`
+ *    (`neetru products create`) exige papel admin ou operator; cada produto tem
+ *    endereço próprio (um por produto e ambiente), banco próprio (banco por
+ *    produto) e segredos próprios;
+ *  - o deploy do produto novo exige que a CHAVE da CLI o alcance. A rota de
+ *    deploy (`/api/cli/v1/deploy`) devolve 403 `forbidden_product` quando
+ *    `cliPrincipalCanAccessProduct` nega: admin passa sempre; as outras chaves
+ *    só passam com `'*'` ou o produto em `allowedProducts`. Chave de operator
+ *    nasce com escopo de produto EXPLÍCITO (`createCliApiKey` recusa operator
+ *    sem `allowedProducts`), o `neetru auth login` só emite chave (`'*'`) para
+ *    admin, e nenhuma ação de `cli-keys.ts` (criar, listar, revogar) muda o
+ *    escopo de uma chave existente. Logo o texto diz o que é certo — admin
+ *    alcança todos; chave com escopo, só os dela, e o deploy do novo volta 403
+ *    e fica com um admin — sem prometer um jeito de ampliar a chave que o Core
+ *    não tem. Sem esta linha, um operator criava o produto e batia no 403 no
+ *    primeiro deploy dele, longe da causa (rodada 3, medido no Core dc45be28);
+ *  - se os dois precisam do MESMO banco, separar em dois produtos não serve
+ *    (o banco é isolado por produto): a API fica dentro do próprio app.
+ *  - `--target cloud-run` NÃO é saída para o mesmo produto e ambiente: o
+ *    ambiente tem um destino só (`_vm-deploy-core.ts` recusa ambiente cujo
+ *    destino não é `vm`), então não aparece no texto.
+ *
+ * Módulo sem dependência: o `index.ts` o importa no topo para a ajuda, e o
+ * resto do deploy continua carregado sob demanda.
+ */
+/**
+ * Aviso de `neetru deploy --target vm --port <n>`: a porta é descartada, e o
+ * dev fica sabendo por que e o que fazer se queria um segundo app.
+ * Continuação recuada para alinhar com o `⚠` do `log.warn`.
+ */
+export declare const AVISO_PORTA_IGNORADA_NA_VM: string;
+/** Bloco da ajuda de `neetru deploy --help` (`addHelpText('after', …)`). */
+export declare const AJUDA_DEPLOY_NA_VM: string;

package/dist/lib/deploy-vm-um-app.js

@@ -0,0 +1,83 @@
+/**
+ * Deploy na VM: um app por produto e ambiente — o que a CLI diz ao dev.
+ *
+ * ORIGEM — bug_6d92ef71. A descrição tinha duas metades:
+ *
+ *  1. `neetru deploy --target vm --port 3001` descartava a porta sem avisar.
+ *     Consertado antes (P6, f3a9611, d327d30): a CLI avisa que o Core escolhe
+ *     a porta.
+ *  2. "não fica claro como subir dois processos do mesmo produto (ex.: web e
+ *     API em subdomínios diferentes) na mesma VM: dois deploys --product=X
+ *     --env prod provavelmente se substituem."
+ *
+ * A metade 2 foi MEDIDA no Core (vistoria de 22/10) e é verdadeira:
+ *  - `appKeyOf(productId, environmentId)` (src/lib/ports/port-registry.ts) é a
+ *    identidade do app na VM — produto + ambiente, nada mais;
+ *  - `ensureStableProxyPort` (src/lib/actions/_vm-deploy-core.ts) reusa a
+ *    MESMA porta para o mesmo par, e o deploy novo troca o app que está nela;
+ *  - `syncEnvironmentSubdomainPortCore` (src/lib/actions/_product-subdomains-cores.ts)
+ *    guarda UM endereço por (produto, ambiente) e o aponta para a porta e o
+ *    servidor do último deploy;
+ *  - o deploy da CLI não tem flag para nomear um segundo app do mesmo produto.
+ *
+ * O aviso do conserto 1 confirmava a limitação e não dava saída: quem passa
+ * `--port` quase sempre quer subir um SEGUNDO app, e depois do aviso seguia
+ * sem caminho. Aqui fica a resposta, escrita uma vez e usada nos dois lugares
+ * onde o dev a encontra: o aviso do `--port` (`runDeploy`) e a ajuda do
+ * `neetru deploy --help` (`index.ts`).
+ *
+ * O caminho que existe hoje, medido no Core:
+ *  - dois apps = dois produtos. `POST /api/cli/v1/products`
+ *    (`neetru products create`) exige papel admin ou operator; cada produto tem
+ *    endereço próprio (um por produto e ambiente), banco próprio (banco por
+ *    produto) e segredos próprios;
+ *  - o deploy do produto novo exige que a CHAVE da CLI o alcance. A rota de
+ *    deploy (`/api/cli/v1/deploy`) devolve 403 `forbidden_product` quando
+ *    `cliPrincipalCanAccessProduct` nega: admin passa sempre; as outras chaves
+ *    só passam com `'*'` ou o produto em `allowedProducts`. Chave de operator
+ *    nasce com escopo de produto EXPLÍCITO (`createCliApiKey` recusa operator
+ *    sem `allowedProducts`), o `neetru auth login` só emite chave (`'*'`) para
+ *    admin, e nenhuma ação de `cli-keys.ts` (criar, listar, revogar) muda o
+ *    escopo de uma chave existente. Logo o texto diz o que é certo — admin
+ *    alcança todos; chave com escopo, só os dela, e o deploy do novo volta 403
+ *    e fica com um admin — sem prometer um jeito de ampliar a chave que o Core
+ *    não tem. Sem esta linha, um operator criava o produto e batia no 403 no
+ *    primeiro deploy dele, longe da causa (rodada 3, medido no Core dc45be28);
+ *  - se os dois precisam do MESMO banco, separar em dois produtos não serve
+ *    (o banco é isolado por produto): a API fica dentro do próprio app.
+ *  - `--target cloud-run` NÃO é saída para o mesmo produto e ambiente: o
+ *    ambiente tem um destino só (`_vm-deploy-core.ts` recusa ambiente cujo
+ *    destino não é `vm`), então não aparece no texto.
+ *
+ * Módulo sem dependência: o `index.ts` o importa no topo para a ajuda, e o
+ * resto do deploy continua carregado sob demanda.
+ */
+/** A explicação do modelo e da saída, em linhas. Fonte única dos dois textos abaixo. */
+const UM_APP_POR_AMBIENTE = [
+    'Cada produto tem UM app por ambiente na VM: um novo deploy do mesmo produto no mesmo ambiente',
+    'substitui o app que está no ar (o endereço é o mesmo), em vez de subir um segundo ao lado.',
+    'Dois apps (ex.: site e API em endereços diferentes) são dois produtos: cadastre o segundo com',
+    '`neetru products create` (exige papel admin ou operator) e faça o deploy dele com --product <slug>.',
+    'A chave da CLI precisa alcançar o produto novo: a de admin alcança todos; uma chave com escopo',
+    'de produto, só os dela — o deploy do novo volta 403 (forbidden_product) e fica com um admin.',
+    'Cada produto tem endereço, banco e segredos próprios. Se os dois precisam do mesmo banco,',
+    'sirva a API pelo próprio app (ex.: rotas /api), no mesmo endereço.',
+];
+/**
+ * Aviso de `neetru deploy --target vm --port <n>`: a porta é descartada, e o
+ * dev fica sabendo por que e o que fazer se queria um segundo app.
+ * Continuação recuada para alinhar com o `⚠` do `log.warn`.
+ */
+export const AVISO_PORTA_IGNORADA_NA_VM = [
+    '--port é ignorado em deploy na VM: quem escolhe a porta é o Core.',
+    ...UM_APP_POR_AMBIENTE,
+].join('\n    ');
+/** Bloco da ajuda de `neetru deploy --help` (`addHelpText('after', …)`). */
+export const AJUDA_DEPLOY_NA_VM = [
+    '',
+    'Na VM (--target vm):',
+    '  A porta é escolhida pelo Core; --port é ignorado.',
+    ...UM_APP_POR_AMBIENTE.map((linha) => `  ${linha}`),
+    '',
+].join('\n');
+//# sourceMappingURL=deploy-vm-um-app.js.map

package/dist/lib/segredo-produto.d.ts

@@ -1,10 +1,25 @@
 export { CARACTERE_DE_TROCA, CodificacaoInvalida, decodificarUtf8, semBomInicial, type OrigemDosBytes, } from './texto-utf8.js';
 /**
- * Aviso de que o segredo registrado ainda não chega ao app na VM. Com data:
- * quando o agente for liberado, a frase fica visivelmente velha em vez de
- * mentir calada. Mesmo fato que o Core declara no `assertNoSecretEnvVars`.
+ * Primeira versão PUBLICADA do agente da VM que entrega os segredos do produto
+ * ao app (Parte 2 de bug_8b85353b, agent#87): com `productEnv: true` no
+ * `agent.deploy`, ele busca os valores no Core e grava
+ * `/etc/neetru/<slug>.product.env` (root, 0600), lido pelo unit do app.
+ *
+ * Por que 1.6.80 e não 1.6.79: o CHANGELOG do agente põe o recurso na 1.6.79,
+ * mas essa versão foi declarada e nunca publicada; `agent_releases/1.6.80`
+ * (stable) saiu em 2026-10-20 e as duas VMs operacionais (snee-002-multi e
+ * snee-003-db) reportam 1.6.80 desde 2026-10-22 (medido na vistoria de 22/10).
+ * Agente mais velho ignora `productEnv` calado — por isso a versão vai na nota.
+ */
+export declare const AGENTE_MINIMO_SEGREDO_DO_PRODUTO = "1.6.80";
+/** Nota depois de `neetru secrets set` gravar: o app só vê a gravação no PRÓXIMO deploy. */
+export declare function notaEntregaDoSegredo(ambiente: string): string;
+/**
+ * Nota do `neetru deploy --target vm` depois de descartar do `--env-file`
+ * chave(s) com cara de segredo que o registro aceita. `env` é o `--env` cru do
+ * deploy: sai no nome canônico que o Core aceita, ou `<ambiente>`.
  */
-export declare const AVISO_AGENTE_PENDENTE: string;
+export declare function notaSegredoDescartadoNoDeploy(env: string | undefined): string;
 /**
  * O comando que registra `chave` no ambiente do deploy. `env` é o `--env` cru
  * do deploy (`dev`, `production`…): sai no nome canônico que o Core aceita, ou
@@ -57,8 +72,13 @@ export declare function problemaNaChaveReservada(chave: string): string | null;
  * Por que a chave é recusada, ou `null` se serve. NUNCA repete o que foi
  * digitado: `KEY=valor` e o valor colado no lugar do nome são os dois erros
  * mais prováveis, e ecoar a entrada imprimiria o segredo.
+ *
+ * `comoMandarOValor`: por onde o valor entra NO COMANDO que chamou (o `set`
+ * passa "por --stdin, --from-file ou pelo pedido na tela"). bug_89d2497e
+ * (etapa 1): o texto citava essas flags a todo chamador, e o `secrets archive`
+ * — que não recebe valor nem declara as flags — também o mostrava.
  */
-export declare function problemaNaChave(chave: string | undefined): string | null;
+export declare function problemaNaChave(chave: string | undefined, comoMandarOValor?: string): string | null;
 /**
  * Por que o valor é recusado, ou `null` se serve. Mesma regra do Core e do
  * agente: o valor vira uma linha de `EnvironmentFile` do systemd, e o agente