@growconnect/growtickets-nest 0.1.0 → 0.3.0

package/.env.example

@@ -1,2 +1,10 @@
 GROWTICKETS_URL=
 GROWTICKETS_API_KEY=
+GROWTICKETS_TRUSTED_PROXY_HOPS=1
+GROWTICKETS_TRUST_REAL_IP=false
+GROWTICKETS_ENV_KEY=
+GROWTICKETS_ENV_PATH=growtickets/env
+GROWTICKETS_ENV_ON_FAILURE=keep
+GROWTICKETS_ENV_MAX_STALE_HOURS=168
+GROWTICKETS_ENV_ON_CHANGE=restart
+GROWTICKETS_ENV_EXIT_CODE=75

package/README.md

@@ -1,6 +1,6 @@
 # @growconnect/growtickets-nest
 
-GrowTickets para **NestJS** (10, 11 y 12, con **Express o Fastify**), en dos mitades que no se necesitan entre sí:
+GrowTickets para **NestJS** (10, 11 y 12, con **Express o Fastify**), en tres mitades que no se necesitan entre sí:
 
 - **El proxy del portal**: guarda `GROWTICKETS_API_KEY`, firma quién reporta con la sesión del producto y reenvía a
   `api/ingest` por una lista blanca de 9 rutas. Es el mismo contrato que `growtickets-laravel` y
@@ -9,6 +9,10 @@ GrowTickets para **NestJS** (10, 11 y 12, con **Express o Fastify**), en dos mit
 - **La seguridad del producto** (opcional, apagada por defecto): manda a la mesa de ayuda lo que ve pasar, **corta a
   las IP que ella bloquee**, contesta la ruta de salud con la que sabe si el producto se cayó y reenvía la lista de
   paquetes de tu front. Ver [Seguridad y disponibilidad](#seguridad-y-disponibilidad).
+- **Los logs** (0.2.0, opcional): lo que escribe el logger de Nest se manda además a GrowTickets, con los secretos tapados, para buscarlo
+  y agrupar lo repetido. Ver [Logs](#logs-020).
+- **Las variables de entorno desde GrowTickets** (0.3.0, opcional): el servidor trae sus variables, cifradas, de la pestaña «Entornos» del
+  proyecto, y «Vincular» las aplica en segundos. Ver [Variables de entorno desde GrowTickets](#variables-de-entorno-desde-growtickets-030).
 
 No trae pantallas: Nest es tu backend y el portal lo pinta tu front.
 
@@ -182,9 +186,11 @@ ficha del proyecto.
 | `GROWTICKETS_SECURITY_BLOCKING` | `true` | `false` sigue capturando pero nunca corta una petición. |
 | `GROWTICKETS_SECURITY_HEALTH_PATH` | `growtickets/health` | Dónde contesta la ruta de salud (sin barras en los extremos, sin el prefijo global). `off` la apaga. |
 | `GROWTICKETS_TRUSTED_PROXY_HOPS` | `1` | Cuántos proxies de confianza hay delante (1 = Railway; con Cloudflare delante de Railway, 2). `0` = sin proxy. |
+| `GROWTICKETS_TRUST_REAL_IP` | `false` | Lee `X-Real-IP` cuando `X-Forwarded-For` no da una IP, para un proxy que sólo escribe ésa. Apagado, esa cabecera la puede mandar cualquiera. |
 | `GROWTICKETS_FRONT_DEPS_TOKEN` | vacío | El token de build del front (ver [Dependencias de un front](#dependencias-de-un-front-que-vive-en-otro-repo)). Vacío = el relevo no existe. |
 | `GROWTICKETS_FRONT_DEPS_PATH` | `growtickets/front-deps` | Dónde recibe el relevo. `off` lo quita. |
 | `GROWTICKETS_SECURITY_DEPENDENCIES` | `true` | `false` apaga el relevo aunque tenga token. |
+| `GROWTICKETS_SECURITY_CSP` | `true` | `false` quita la política «sólo informar» de GrowTickets (la de tu `csp` de `forRoot` se queda). Ver [Política de contenido](#política-de-contenido-sólo-informar-030). |
 
 Una variable mal escrita cae a su valor por defecto: la seguridad nunca lanza ni tumba una petición. Se leen al
 arrancar el proceso y en cada petición, no al compilar.
@@ -198,7 +204,9 @@ Corre **antes** que el router, los guards y el parser de cuerpo, en Express y en
    No revela versiones ni tablas.
 2. **Una IP bloqueada** recibe 403 (`{ "message": "Acceso bloqueado." }`, o texto si pide HTML) y no llega a tu app.
 3. **El relevo del front** (`POST /growtickets/front-deps`) se contesta ahí con el token de build.
-4. **Todo lo demás sigue**, y al terminar la respuesta se cuenta con su código real.
+4. **El mantenimiento**: la ruta del front se contesta ahí, y con una ventana de GrowTickets en curso que toca a este
+   servidor se responde 503. Ver [Mantenimiento](#mantenimiento-ventanas-programadas-desde-growtickets-020).
+5. **Todo lo demás sigue**, y al terminar la respuesta se cuenta con su código real.
 
 Lo que se cuenta: el **tráfico** por minuto y por PLANTILLA de ruta (`GET /api/orders/[id]`, nunca la URL ni la query),
 con su reparto de códigos y su latencia; **`access.unauthorized` / `forbidden` / `rate_limited`** para 401, 403 y 429,
@@ -265,6 +273,35 @@ security: { checks: { database: () => dataSource.query('select 1') } }   // con
 
 `false` o una excepción son un 503 que la mesa de ayuda cuenta como caída. Sin `checks` no se mira ninguna base.
 
+### Política de contenido «sólo informar» (0.3.0)
+
+Si el proyecto enciende la política de contenido en GrowTickets (sección Seguridad), la configuración remota trae `csp: { policy, report_uri }` y el
+middleware de `main.ts` la **suma** a lo que ya tenga la respuesta, en UNA `Content-Security-Policy-Report-Only` (el navegador evalúa e informa
+cada política por su lado, así ninguna pierde), y fusiona `Reporting-Endpoints` con `growtickets-csp="…"`:
+
+```
+Content-Security-Policy-Report-Only: <la tuya>, <la de GrowTickets>; report-uri <destino>; report-to growtickets-csp
+Reporting-Endpoints: <los tuyos>, growtickets-csp="<destino>"
+```
+
+- **Sólo páginas**: una respuesta 2xx de tipo HTML a un `GET`/`HEAD` que pide una página (`Sec-Fetch-Dest: document`, o que acepta
+  `text/html` si el navegador no lo manda). Ni un JSON, ni una redirección, ni un error, ni un `POST`. La suma se hace al escribir las cabeceras
+  (`writeHead`), así que ve lo que tu app —helmet, un interceptor, un controlador— haya puesto.
+- **Nunca toca `Content-Security-Policy`**, la que bloquea. Una política idéntica no se repite; si un grupo de `Reporting-Endpoints` coincide, gana el tuyo.
+- **Tu propia política** se declara en el `forRoot` (se aplica aunque la seguridad esté apagada):
+
+```ts
+GrowTicketsModule.forRoot({
+  resolveReporter,
+  csp: { reportOnly: ["frame-ancestors 'none'"], reportingEndpoints: { 'mi-csp': '/informes' } },
+});
+```
+
+  Una opción inválida (varias líneas, no ASCII, más de 4096 caracteres, un grupo con un destino raro) **lanza `ConfigurationError` al montar el módulo**
+  —no se descarta en silencio—, y el mensaje dice qué opción falló sin repetir su valor.
+- **Lo que llega de la central se vuelve a validar**: una línea imprimible de hasta 4096 caracteres, sin comas (la coma separa políticas) y un
+  `report_uri` http(s); si no, se ignora. `GROWTICKETS_SECURITY_CSP=false` la quita sin tocar el código.
+
 ### Bloques de red
 
 Además de IP sueltas, GrowTickets puede cerrar un **país, una red (ASN) o las salidas de Tor**. Esos bloques son miles de
@@ -308,7 +345,8 @@ Las dependencias del **propio servidor Nest** se mandan desde CI con [`npx growt
   manda sus lotes, y la mesa de ayuda los suma.
 - **La IP** sale de `X-Forwarded-For` contando `GROWTICKETS_TRUSTED_PROXY_HOPS` desde la DERECHA: lo que escribe el cliente
   va a la izquierda y no cuenta. No depende del `trust proxy` de Express. Con un número equivocado todas las peticiones
-  parecen de la misma IP privada; la librería lo detecta y avisa a la mesa de ayuda (`no_trusted_proxies`).
+  parecen de la misma IP privada; la librería lo detecta y avisa a la mesa de ayuda (`no_trusted_proxies`). Sin proxy delante:
+  `GROWTICKETS_TRUSTED_PROXY_HOPS=0`; `X-Real-IP` sólo con `GROWTICKETS_TRUST_REAL_IP=true`.
 - **La dirección pública del producto** se aprende de las respuestas 2xx (con `X-Forwarded-Host`/`-Proto` detrás de un
   proxy) y viaja con cada lote: de ahí sale la sugerencia de dominio en «Disponibilidad».
 - **Fastify** contesta 415 a un `POST` sin `Content-Type` antes de que llegue al proxy (el contrato pide 403). Sigue
@@ -316,6 +354,246 @@ Las dependencias del **propio servidor Nest** se mandan desde CI con [`npx growt
 - **Sin política de contenido (CSP)** en esta versión: Nest sirve JSON y el HTML lo sirve tu front. **Sin integridad de
   archivos**: los despliegues de un producto Node son inmutables, y comparar archivos no aportaría nada.
 
+## Logs (0.2.0)
+
+Lo que escribe el logger de Nest llega a GrowTickets, para buscarlo, agrupar lo repetido y ver un archivo por servidor. **No cambia lo que ya
+sale por la consola**: es el `ConsoleLogger` de Nest —mismo formato, mismos colores— al que se le añade el envío.
+
+```ts
+import { GrowTicketsLogService } from '@growconnect/growtickets-nest';
+
+const app = await NestFactory.create(AppModule, { logger: new GrowTicketsLogService() });
+app.enableShutdownHooks();
+```
+
+Y la clave de la pestaña «Claves de API» del proyecto (la Principal ya lleva el alcance «Logs»; si usas otra, márcalo allí), con el módulo «Logs»
+encendido en «General». Para que al cerrar la app se mande lo último, importa el módulo de los logs (o el `GrowTicketsModule`, que ya lo trae):
+
+```ts
+@Module({ imports: [GrowTicketsLogsModule] })
+export class AppModule {}
+```
+
+- **Cada línea** llega con su nivel (`log`→`info`, `warn`→`warning`, `verbose`→`debug`, `fatal`→`critical`) y su **contexto como canal**
+  (`PagosService`, `NestFactory`, `ExceptionsHandler`).
+- **El error**: un `Error` entre los argumentos, o la pila que Nest recibe aparte (`logger.error('Falló', err.stack, 'PagosService')`), es la
+  excepción de la línea, con su clase, el archivo y la línea de donde salió y su traza (rutas relativas a tu carpeta).
+- **Lo que Nest escribe al arrancar** (`NestFactory`, `InstanceLoader`, `RoutesResolver`) también llega; `GROWTICKETS_LOGS_LEVEL` sube el mínimo.
+- **Con `nestjs-pino`** usa la salida de pino: `LoggerModule.forRoot({ pinoHttp: { stream: growTicketsLogStream() } })`.
+
+### Lo que se tapa antes de salir
+
+- Por **nombre de campo**: `password`, `token`, `secret`, `api_key`, `authorization`, `cookie`… y las palabras que añadas en
+  `GROWTICKETS_LOGS_REDACT_KEYS` (`cpf,documento`).
+- Por **forma**: `Bearer …`, un JWT, una clave de GrowTickets o de AWS, credenciales en una URL, una clave privada y los pares `clave=valor`.
+- Por **valor**: los secretos que tu entorno tiene de verdad (`DATABASE_URL`, `STRIPE_SECRET_KEY`, cualquier `*_TOKEN`, `*_KEY`, `*_DSN`) se
+  tapan dondequiera que aparezcan.
+- **Nunca se ejecuta código tuyo**: un objeto con `toJSON()` o con getters en el contexto sale como `[object Clase]`.
+
+GrowTickets lo vuelve a tapar al recibirlo y puede además tachar los **datos personales** (correos, cédulas, celulares) con un interruptor del
+proyecto («Tachar datos personales», en «General»).
+
+### Variables
+
+| Variable | Qué hace |
+|---|---|
+| `GROWTICKETS_LOGS` | `false` apaga los logs sin tocar el código. |
+| `GROWTICKETS_LOGS_LEVEL` | El nivel más bajo que se manda (`debug` de serie). |
+| `GROWTICKETS_LOGS_ORIGIN` | La dirección pública del producto, si quieres fijarla. |
+| `GROWTICKETS_LOGS_REDACT_KEYS` | Palabras que hacen que se tape el valor de un campo, separadas por comas. |
+
+### Cómo funciona
+
+Capturar es síncrono, barato y **nunca lanza**: una línea que no se entiende, un error al tapar o la cola llena se pierden en silencio y
+jamás rompen el log ni la petición. Cada minuto se manda lo acumulado, comprimido, en lotes de hasta 2.000 líneas; **una línea `warning` o
+peor se manda a los cinco segundos**, para que un fallo no se lleve el último minuto. Un lote se reintenta con el mismo identificador, tras
+tres fallos seguidos hay un corte de cinco minutos y lo que lleva más de una hora esperando se descarta y se cuenta como perdido (la central
+lo sabe). Por encima de 5.000 líneas por minuto se muestrea lo leve con peso; lo grave se manda **siempre**.
+
+Los archivos de log de un servidor Node **no se pueden gestionar desde GrowTickets** (escriben a la consola): se ven en el explorador, como
+`project.log` y como un archivo por servidor («NestJS»).
+
+```bash
+npx growtickets-nest doctor          # entorno, clave, alcance «Logs» y módulo encendido
+npx growtickets-nest doctor --send   # además manda una línea de prueba y comprueba que llega
+```
+
+## Mantenimiento: ventanas programadas desde GrowTickets (0.2.0)
+
+Una ventana se programa en la pestaña «Mantenimiento» del proyecto (a qué se aplica, desde cuándo, hasta cuándo, el mensaje y desde
+cuándo se avisa) y el middleware de `main.ts` la cumple. **Viene encendido** y no hace falta tocar nada más: sin ventanas no se nota.
+
+| Variable | Por defecto | Qué hace |
+|---|---|---|
+| `GROWTICKETS_MAINTENANCE` | `true` | `false` lo apaga: no pregunta, no cierra y la ruta del front no existe. |
+| `GROWTICKETS_MAINTENANCE_HOST` | la aprendida | La dirección de ESTE servidor (`https://api.empresa.co`), para las ventanas «por dominios». Sin ella vale la que aprende la seguridad. |
+| `GROWTICKETS_MAINTENANCE_PATH` | `api/growtickets/maintenance` | Por dónde pregunta el front (la ruta CRUDA, con el prefijo global si lo hay). |
+
+- **Pregunta a GrowTickets cada minuto** (`GET api/ingest/maintenance`) y guarda la respuesta en memoria. Las peticiones nunca esperan esa
+  pregunta, salvo las primeras al arrancar (como mucho 2 s): es lo que hace que un servidor desplegado DURANTE la ventana salga ya cerrado.
+  Si GrowTickets no contesta sigue con lo último que supo; sin nada, atiende con normalidad. **Nunca tumba tu producto.**
+- **Activa y apaga POR RELOJ** —el de GrowTickets, corregido—: la ventana empieza y termina a su hora aunque la central no conteste.
+- **Mientras una ventana toque a este servidor responde 503** con `Retry-After`: JSON en las rutas `api/*` y en todo lo que no pida HTML
+  (`{ success: false, message, data: { maintenance: { title, message, starts_at, ends_at } } }`), y la página del proyecto a un navegador. Una
+  ventana por «partes» toca a este servidor si incluye el *backend*; por «dominios», si llegas por una de sus direcciones.
+- **El pase del equipo** (se ve en la ventana) entra sin que se note: cabecera `X-GrowTickets-Bypass`, cookie, o `?growtickets_bypass=…` una vez,
+  que deja una cookie de 12 h.
+- **Nunca se cierran** la ruta de salud, `growtickets/*` ni la del front.
+- **Para un front** (`growtickets-ng` ≥ 0.7, `growtickets-next-react` ≥ 0.5, `growtickets_flutter` ≥ 0.5): pregunta a ESTE servidor en
+  `api/growtickets/maintenance` y recibe en `windows` las ventanas que le tocan y en `backend_windows` las que cierran este servidor (para
+  cerrar la sesión y decirlo en su login). El pase nunca sale hacia el navegador. La ruta trae su propio CORS (`*`, sin credenciales).
+- ⚠️ **Con el front en otro dominio**, `app.enableCors()` va ANTES de `app.use(growTicketsMiddleware(app))`: así el 503 de una ventana lleva
+  las cabeceras de CORS y el front puede leer el motivo.
+
+### Zonas: a quién le afecta (0.2.0)
+
+Una ventana puede aplicarse a **zonas** en lugar de a todo: el panel administrativo, el portal de clientes… Se crean en la pestaña «Mantenimiento» del
+proyecto: cada una tiene una **clave** (`empresas`), las rutas de sus **pantallas** (`/enterprise`) y las de su **API** (`/api/empresas`). Una ventana de zonas
+no silencia dominios: el producto sigue sirviendo a los demás, y la central no esconde una caída real.
+
+- **Por ruta, sin tocar nada**: el middleware de `main.ts` cierra con 503 lo que cae en una zona (`/api/empresas/x`, `/enterprise/inicio`) y deja todo lo demás.
+  Las rutas casan por segmento (`/admin` casa `/admin/x`, no `/administrador`) y sin distinguir mayúsculas. Lo que no está en ninguna zona —el login, la
+  autenticación, el soporte— nunca se cierra por zona.
+- **Por público, cuando la API es la misma para todos**: si el equipo y las empresas usan `/api/afiliados`, la ruta no distingue a nadie. Dile a la librería
+  de qué público es cada petición con tu sesión, devolviendo la clave de la zona, y pon el guard donde ya sabes quién es:
+
+```ts
+GrowTicketsModule.forRoot<Req>({
+  resolveReporter,
+  maintenance: { audience: (req) => (req.user?.rol === 'empresa' ? 'empresas' : req.user ? 'panel' : null) },
+});
+
+@UseGuards(JwtAuthGuard, GrowTicketsMaintenanceGuard)   // DESPUÉS del que deja a la persona en la petición
+@Controller('afiliados')
+export class AfiliadosController {}
+```
+
+  ⚠️ El guard **no** se registra solo como global: uno global corre antes que los tuyos, no vería a nadie y no cerraría nada en silencio. No se lo pongas al login,
+  al logout ni al soporte: lo que no lo lleva nunca se cierra por público. Sin resolutor, o si devuelve nada, deja pasar. Con él, la central sabe que este
+  servidor resuelve el público (si una zona depende de eso y no lo resuelve, la pantalla de la central lo avisa).
+- **Para el front**: `zone_windows` en la ruta del front lleva las ventanas de zonas con sus pantallas (nunca la API); es el front quien decide si le tocan.
+
+### La versión de Node
+
+Desde la 0.2.0 cada llamada a GrowTickets lleva `X-GrowTickets-Runtime: node/22.11.0 nestjs/11.0.5` (la versión COMPLETA: un aviso de Node se
+decide por el parche). Es lo que deja a la central decir «tu Node está dentro del rango vulnerable» en la sección de seguridad, aunque la
+seguridad esté apagada. Es información: no autoriza nada.
+
+## Variables de entorno desde GrowTickets (0.3.0)
+
+Las variables de cada servidor viven **cifradas en la central** (pestaña «Entornos» del proyecto) y el servidor se queda con dos. «Vincular» en la
+central las aplica en **segundos**, sin desplegar. Es el mismo protocolo (**GT-ENV2**) que `growtickets-laravel` 0.11.0.
+
+1. En la pestaña «Entornos», crea el entorno (Producción, Pruebas…), carga sus variables (o pega tu `.env`: entra todo como secreto) y pulsa **Vincular**.
+2. **Conectar un servidor**: eliges el dominio (de la pestaña «Dominios») al que la central avisará y escribes tu código de dos pasos. La llave del servidor nace
+   en tu navegador y a la central sólo va la **pública**; te enseña la credencial **una sola vez**. Si prefieres que la privada no salga nunca del servidor (uno
+   propio, con su `.env`): `npx growtickets-nest env keygen`, pega la pública que te da en «Ya tengo una llave pública», y termina con
+   `npx growtickets-nest env keygen --central=<la llave de la central> --write`.
+3. En el servidor, **en las variables de la plataforma** (no en un `.env` versionado):
+
+```bash
+GROWTICKETS_URL=https://tu-growtickets
+GROWTICKETS_ENV_KEY=gtk2....
+```
+
+4. En `main.ts`, **antes** de `NestFactory.create` (y por tanto antes de que `ConfigModule` lea nada):
+
+```ts
+import { growTicketsMiddleware, loadGrowTicketsEnv } from '@growconnect/growtickets-nest';
+
+async function bootstrap() {
+  await loadGrowTicketsEnv();                       // trae las variables y las pone en process.env
+  const app = await NestFactory.create(AppModule);
+  app.use(growTicketsMiddleware(app));              // contesta el aviso de «Vincular» y el reto de identidad (y la ruta de salud, y el resto)
+  await app.listen(3000);
+}
+```
+
+`loadGrowTicketsEnv()` lee `process.env`: `GROWTICKETS_URL` y `GROWTICKETS_ENV_KEY` tienen que estar ya en el entorno del proceso (la plataforma
+los pone). En local con un `.env`, cárgalo antes: `node --env-file=.env dist/main.js`, o `process.loadEnvFile()` en la primera línea.
+Sin `GROWTICKETS_ENV_KEY` no hace nada y devuelve `{ status: 'off' }`: se puede dejar puesta en todos los productos antes de conectar ninguno.
+Compruébalo con `npx growtickets-nest env status` (dice el `key_id` de la credencial, el mismo que enseña el panel). Hace falta Node 18.18 o superior.
+
+### Seguridad: la credencial nunca viaja
+
+`GROWTICKETS_ENV_KEY` (`gtk2.<semilla>.<pública de la central>`) no se manda nunca: con ella la librería **firma** cada petición (Ed25519, con la hora, un nonce de
+un solo uso y las cabeceras que la identifican) y **fija** la llave de la central. Al bajar manda además una llave efímera X25519, y la central le contesta **cifrado
+para esa petición** (ChaCha20-Poly1305): ni quien capture el tráfico, ni quien robe la credencial después, puede leer lo que viajó. Todo lo que contesta la central va
+**firmado** por ella; un 304, un «revocada» o unas variables sin esa firma no cambian nada (`unsigned_response`: se sigue con la copia), y una entrega en claro no se acepta
+aunque venga firmada. La central, además, puede limitar desde qué red se pide (una lista de IPs). El reloj tiene que ir a ±2 minutos del de la central.
+
+Lo que esto no cubre: quien controle tu servidor o las variables de tu plataforma ve la credencial. Si un servidor se compromete, rota en la central su credencial por **filtración**
+—y los secretos que tenía—. El protocolo para otras librerías está en el README de `growtickets-laravel` («Protocolo GT-ENV2»), con un vector común que esta librería pasa byte a byte.
+
+| Variable | Por defecto | Qué hace |
+|---|---|---|
+| `GROWTICKETS_ENV_KEY` | vacía | La credencial de **servidor** (`gtk2.` y 92 caracteres), no la clave de API. Vacía = la pieza está apagada. Nunca en `.env.example`: `check` falla si lleva valor. |
+| `GROWTICKETS_ENV_PATH` | `growtickets/env` | Por dónde avisa la central: `POST {ruta}/apply` y `GET {ruta}/identity`, **fuera del prefijo global**. Sólo letras, números, `/`, `_` y `-`. |
+| `GROWTICKETS_ENV_ON_FAILURE` | `keep` | Si la central no contesta al arrancar: `keep` usa la copia local; `fail` no arranca. |
+| `GROWTICKETS_ENV_MAX_STALE_HOURS` | `168` | Cuántas horas puede tener la copia local para arrancar con ella. |
+| `GROWTICKETS_ENV_ON_CHANGE` | `restart` | Qué hacer al llegar una versión nueva con el proceso en marcha: `restart` o `reload` (ver abajo). |
+| `GROWTICKETS_ENV_EXIT_CODE` | `75` | Con `restart`: el código con que sale el proceso (0 a 255). Ver «`restart` o `reload`». |
+| `GROWTICKETS_ENV_DIR` | `.growtickets/` junto al proceso | Dónde guarda la copia cifrada y el estado. Si no se puede escribir ahí cae a una carpeta privada del directorio temporal. |
+| `GROWTICKETS_ORIGIN` | vacía | La dirección pública del producto: la central la cruza con el dominio elegido al conectar el servidor. |
+
+### Quién gana
+
+**entorno de la plataforma < la central < `GROWTICKETS_URL` y `GROWTICKETS_ENV_KEY` del arranque.** Lo que la central define pisa lo que pusieron Docker
+o Railway y un `.env` que lea tu app después (`dotenv` no pisa lo que ya está en `process.env`); lo que no define se sigue leyendo de donde estuviera.
+La central **nunca** puede tocar nada con el prefijo `GROWTICKETS_` (son las claves de la librería, sus logs remotos y su seguridad), ni las variables que gobiernan
+el proceso (`PATH`, `HOME`, `LD_*`, `DYLD_*`, `NODE_OPTIONS`, `NODE_PATH`, `NODE_EXTRA_CA_CERTS`, `NODE_TLS_REJECT_UNAUTHORIZED`…): se descartan, se avisa
+por el error estándar **sólo su nombre** y `growtickets-nest env status` las lista. Hasta 1000 variables de hasta 32 KB.
+
+### «Vincular» al instante
+
+La central avisa con `POST /growtickets/env/apply` (cámbialo con `GROWTICKETS_ENV_PATH`), **firmado** con su llave —la fijada en tu credencial—, para ESTE servidor y de un
+solo uso: `GT-ENV2-PUSH` sobre el `key_id` de este servidor, la hora, un nonce y el SHA-256 del cuerpo. Se tolera un minuto de reloj y cada nonce se recuerda dos. Cualquier otra
+cosa —sin firma, con otra, para otro servidor, vieja, repetida, con query, con otro método, con un cuerpo de más de 256 bytes— recibe un **404 corriente**; no se escribe
+nada (ni el nonce) antes de verificar la firma.
+
+El aviso no trae ningún valor, sólo `{"version": N}`. El servidor contesta **202 al instante** y, **después de responder**, pregunta a la central por su cuenta (firmado, por
+https, con `If-None-Match`), aplica y confirma. Un aviso falsificado, en el peor caso, le hace preguntar. La ruta la contesta el middleware de `main.ts` —igual que la de
+salud—, por eso queda fuera del prefijo global y de los guards de tu app. Regístralo **antes** de cualquier parser de cuerpo (así lo hace `app.use(growTicketsMiddleware(app))`).
+
+La central también reta a tu dominio a demostrar que tiene esta credencial (`GET /growtickets/env/identity?challenge=…`, una vez al día y con «Confirmar el dominio»): sólo contesta
+a un reto firmado por la central, y si el dominio responde con otra credencial, la central avisa. Lo que contesta no lleva ningún secreto: el `key_id`, la pública y la firma del reto.
+
+### `restart` o `reload`
+
+- **`restart`** (de serie): tras confirmar, la librería cierra la app en orden (`app.close()`, que también manda los últimos logs) y **sale con código 75**
+  (`EX_TEMPFAIL`, «vuelve a intentarlo»); el gestor de procesos tiene que levantarla otra vez, ya con las variables nuevas. **Es 75 y no 0 a propósito**: Railway
+  (su política de serie es «On Failure»), Docker con `restart: on-failure` y systemd con `Restart=on-failure` **no reinician una salida con 0**, y el producto se quedaría
+  caído tras cada «Vincular». Con `restart: always`, `unless-stopped`, PM2 o Kubernetes da igual el código. Si tu gestor trata un código distinto de 0 como un fallo que
+  alerta, pon `GROWTICKETS_ENV_EXIT_CODE=0` (y que el gestor reinicie ante una salida limpia: en Railway, la política «Always»), o `loadGrowTicketsEnv({ exitCode: 0 })`, que
+  gana sobre la variable. Si no quieres reinicios, usa `reload`.
+- **`reload`**: actualiza `process.env` en caliente (lo que la central deja de mandar vuelve al valor de la plataforma, o se borra) y avisa a quien escuche. **Sólo ve
+  la nueva configuración lo que la lee después**: un pool de conexiones o un cliente ya creado con la vieja no cambia solo.
+
+```ts
+loadGrowTicketsEnv({ onEnvChange: (c) => pool.reconnect() });   // o, desde cualquier provider: onGrowTicketsEnvChange(listener)
+// c = { version, environmentId, environmentName, changed: ['DATABASE_URL'], removed: [] }  — sólo NOMBRES, nunca valores
+```
+
+### Varias réplicas
+
+El aviso entra por el dominio y, detrás de un balanceador, le llega a **una**. Cada proceso, además, **pregunta a la central cada ~60 s** (con un jitter de hasta 15 s y un
+temporizador que no retiene el proceso) con `If-None-Match`: si nada cambió, un 304 sin cuerpo; si cambió, aplica. La central también reintenta el aviso hasta que todas las
+réplicas confirman. Los nonce se recuerdan **en la memoria de cada proceso** (en varias réplicas, una petición firmada capturada podría repetirse una vez por réplica dentro
+del minuto de tolerancia; lo único que consigue es que vuelva a preguntar). Con PM2 en modo cluster cada proceso aplica por su cuenta.
+
+### Si la central no contesta
+
+Cada versión bajada queda en `.growtickets/env.snapshot`, **cifrada** con AES-256-GCM y una llave derivada de tu credencial (permisos 0600, en una carpeta 0700; añade `.growtickets/` al
+`.gitignore`, `check` lo avisa). Con `keep` (de serie) el arranque sigue con esa copia si no tiene más de `GROWTICKETS_ENV_MAX_STALE_HOURS`; con `fail`, o sin copia que sirva,
+`loadGrowTicketsEnv()` **lanza** `EnvError` (con un `reason` corto: `unreachable`, `timeout`, `revoked_key`…) y el producto no arranca: arrancar sin su configuración es peor.
+Una credencial **revocada** o vencida (dicho y firmado por la central) nunca cae a la copia: la borra; una respuesta sin la firma de la central, o desde una red no permitida,
+no: es un fallo pasajero y se sigue con la copia. **No se retrocede**: en el mismo entorno, una versión menor que la aplicada o que la de la copia se rechaza
+(`rollback`, se avisa a la central) y la igual no se vuelve a aplicar; cambiar de entorno sí puede bajar el número. Si la central se restauró y volvió a numerar las
+versiones, borra `.growtickets/` para que este servidor acepte la numeración nueva.
+
+La llamada a la central va siempre por **https** (salvo `localhost`, `127.0.0.1`, `::1`, `*.test`, `*.localhost`), **sin seguir redirecciones**,
+con 3 s hasta la respuesta y 10 s en total, y nunca registra ni un valor ni la credencial.
+
 ## CLI: `npx growtickets-nest`
 
 Sin dependencias propias.
@@ -330,9 +608,17 @@ deja ahí.
 ### `check`
 
 De sólo lectura, para el CI del producto. Sale con 1 si `.gitignore` no cubre `.env` o si `.env.example` lleva en una
-`GROWTICKETS_*` un valor que parece un secreto (la clave o el token de build). Además **avisa** —sin cambiar el código de
+`GROWTICKETS_*` un valor que parece un secreto (la clave, el token de build o `GROWTICKETS_ENV_KEY`). Además **avisa** —sin cambiar el código de
 salida— de un montaje que no hará lo que se espera: el módulo sin `growTicketsMiddleware` en `main.ts`, Express sin
-subir el tope de JSON, o un prefijo global con la ruta de serie del portal.
+subir el tope de JSON, un prefijo global con la ruta de serie del portal, y, si usas las variables desde la central, `GROWTICKETS_ENV_KEY` sin
+`loadGrowTicketsEnv()`, llamada después de `NestFactory.create`, sin el middleware o sin `.growtickets/` en el `.gitignore`.
+
+### `doctor [--send]` (0.2.0)
+
+Comprueba los logs de punta a punta: que el entorno traiga la dirección y la clave, que la mesa de ayuda las reconozca, que la clave lleve el
+alcance «Logs» y que el módulo esté encendido en el proyecto. **Los fallos de esta parte no dan error, sólo un explorador vacío.** Con
+`--send` manda además una línea de prueba y comprueba que llega. Sale con 1 si algo impide que las líneas lleguen. Si hay `GROWTICKETS_ENV_KEY`, suma el informe de
+[`env status`](#env-pull-env-status-y-env-keygen-030) (y su código de salida).
 
 ### `deps`
 
@@ -342,6 +628,18 @@ viaja el archivo.** Pensado para CI, después de instalar; la clave necesita el
 `GROWTICKETS_ORIGIN`) distingue dos servidores con el mismo nombre. Sale con 1 si no puede enviar y con 0 si la mesa de
 ayuda aún no recibe dependencias o tiene la seguridad apagada: eso no debe frenar un despliegue.
 
+### `env pull`, `env status` y `env keygen` (0.3.0)
+
+`env pull` baja la versión vigente de las variables de este servidor y escribe la **copia local cifrada**, sin poner nada en el entorno de ningún proceso. Dice la versión y
+**cuántas** variables: nunca sus nombres ni sus valores. Sirve para sembrar la copia en un despliegue y para comprobar que la clave funciona; no pisa una copia de una versión posterior.
+`env status` es el doctor y **no usa la red**: la versión aplicada, la edad de la copia, el `key_id` de la credencial (nunca ella), la ruta del aviso y del reto, qué pasa si la central no
+contesta y qué pasa al cambiar una versión (con qué código sale). Ambos leen `GROWTICKETS_URL`, `GROWTICKETS_ENV_KEY` y `GROWTICKETS_ENV_DIR` del entorno; `status` sale con 1 si algo impide aplicar.
+
+`env keygen` genera el par de este servidor **aquí mismo**, para que la privada no pase por un navegador ni un portapapeles: sin opciones guarda la semilla en
+`.growtickets/env.pending` (0600) y enseña sólo la pública y su `key_id` (es lo que va a «Ya tengo una llave pública»); con `--central=<la llave de la central>` arma la credencial y,
+con `--write`, la escribe en el `.env` como `GROWTICKETS_ENV_KEY` si todavía no hay una (nunca la pisa). Sin `--write` la enseña, y entonces queda en el historial de la terminal.
+`--force` genera una semilla nueva aunque haya una pendiente.
+
 ## Cliente servidor a servidor
 
 ```ts
@@ -375,6 +673,8 @@ pudo saber: nunca devuelve un cero que no es).
 | 12 | La clave hacia un proxy de la red en claro | `https` sin depender de `NODE_ENV`, que en Nest casi nunca está |
 | 13 | El ticket de otra persona por el recorte de `max_input_vars` | `reporter_id` primero, tope de 100 valores, y la mesa de ayuda rechaza la query recortada |
 | 14 | Una línea falsa en tus registros (un `%0A` en la URL) | Los mensajes salen con los caracteres de control escapados y cortados a 500 |
+| 15 | Las variables de la central (valores o la clave de servidor) en un registro, un acuse o la salida de la CLI | Sólo versión, cuenta y NOMBRES descartados; la copia local va cifrada (AES-256-GCM, 0600); `env status` enseña un prefijo de la clave |
+| 16 | La clave de servidor hacia otro host | `https` obligatorio, sin seguir redirecciones, y el aviso de la central sólo se atiende con la firma v2 de un solo uso |
 
 ## Cadena de suministro: prácticas recomendadas
 
@@ -396,8 +696,15 @@ npm run test:fixtures   # empaqueta el .tgz, lo instala en Nest 10 + Express, Ne
 Las pruebas de `test/nest` levantan una app de Nest de verdad con **cada plataforma**; las de `test/proxy` y
 `test/security` son las del núcleo.
 
+**El transporte con la central** de las variables de entorno vive aparte, en `src/env/transport/` (cliente HTTP de pull/ack, cabeceras de
+autenticación, verificación del aviso y la derivación de las llaves). El resto de `src/env` —ajustes, política, copia cifrada, aplicación,
+réplicas, arranque, restart/reload— habla con él por la interfaz `EnvTransport` (pedir la versión con ETag, acusar, verificar un aviso, dar la
+llave de la copia) y una prueba (`test/env/transport.spec.ts`) comprueba que no nombra la credencial ni la firma. Otro protocolo se enchufa
+cambiando `createEnvTransport` o pasando otro `transport` a `EnvRuntime`.
+
 **El núcleo es una COPIA** del de `@growconnect/growtickets-next-server` (`packages/server/src` de `growtickets-next`,
-commit `8abdcaa`): `proxy/`, `security/`, `client/`, `errors/`, `logging/`, `config/` y `cli/deps.ts`, sin la CSP, sin el
+commit `8abdcaa`): `proxy/`, `security/`, `client/`, `errors/`, `logging/`, `config/` y `cli/deps.ts`, con la CSP de `security/csp.ts` (la de
+`-next-server`, pero la suma se hace al escribir las cabeceras de Node: `nest/csp-response.ts`), sin el
 runtime edge y sin la comprobación de `NEXT_PUBLIC_*`. Lo de Nest vive en `src/nest/`. Tras la revisión de seguridad del
 2026-10-19 el núcleo además lleva aquí: `reporter_id` primero con `limitQuery` (100 valores) y `phpVariableName` en
 `handle-portal-request.ts`, la valla de origen en todos los métodos (`assertTrustedOrigin`), `safeLogText` en los
@@ -409,6 +716,12 @@ hacerlo también allá** (y al revés): es el mismo contrato con la mesa de ayud
 
 ## Versiones
 
+- **0.3.0** — Las variables de entorno desde GrowTickets (`loadGrowTicketsEnv()`, `onGrowTicketsEnvChange()`, la ruta firmada `POST growtickets/env/apply`, la copia local cifrada, la revisión de
+  cada minuto y `env pull` / `env status`), y la **política de contenido «sólo informar»** que la central define para el proyecto (`GROWTICKETS_SECURITY_CSP`, `csp` en `forRoot`).
+  Ver [Variables de entorno desde GrowTickets](#variables-de-entorno-desde-growtickets-030) y [Política de contenido](#política-de-contenido-sólo-informar-030).
+- **0.2.0** — Los logs (`GrowTicketsLogService`, `GrowTicketsLogsModule`, `growTicketsLogStream` y `doctor`), el mantenimiento y el lenguaje: el middleware de `main.ts` cumple las ventanas de GrowTickets (503 por reloj, pase del equipo,
+  por zonas —por ruta o por público con `GrowTicketsMaintenanceGuard`—, la ruta del front `api/growtickets/maintenance` con `windows`, `backend_windows` y `zone_windows`), y cada llamada lleva `X-GrowTickets-Runtime`
+  (`node/… nestjs/…`) para los avisos de Node. `GROWTICKETS_MAINTENANCE=false` lo apaga.
 - **0.1.0** — Primera versión: el proxy del portal (con `throttle`) y `GET unread` para el lanzador del componente web, la
   seguridad (bloqueo de IP y de redes, sondeos, logins por decorador, ruta de salud firmada), el relevo de dependencias del
   front, `GrowTicketsClient` (con `sinLeer()`) y el CLI (`init`, `check`, `deps`). Nest 10, 11 y 12, Express y Fastify.

package/dist/cli/args.d.ts

@@ -1,14 +1,22 @@
 export interface ParsedArgs {
     command: string | null;
     dryRun: boolean;
+    /** `--send`: en `doctor`, manda además una línea de prueba y comprueba que llega. */
+    send: boolean;
     /** `--lockfile <ruta>`: el archivo de bloqueo a leer en `deps`, en vez de buscarlo. */
     lockfile: string | null;
     /** `--app <nombre>`: cómo aparece el proyecto en el informe de `deps`. */
     app: string | null;
     /** `--origin <url>`: la dirección pública del producto, para que `deps` distinga este servidor de otro con el mismo nombre. */
     origin: string | null;
+    /** `--central <llave>` (o `--central=<llave>`; sólo con `env`): en `env keygen`, la llave pública de la central que devolvió el panel al conectar. */
+    central: string | null;
+    /** `--write`: en `env keygen --central`, escribe `GROWTICKETS_ENV_KEY` en el `.env`. */
+    write: boolean;
+    /** `--force`: en `env keygen`, genera una llave nueva aunque ya haya una pendiente. */
+    force: boolean;
     /** Banderas que no se reconocen — `runCli` decide qué hacer con ellas, este archivo sólo las señala. */
     unknown: string[];
 }
-/** Analizador de argumentos propio: son cuatro banderas, y así el CLI no arrastra ninguna dependencia. */
+/** Analizador de argumentos propio: son pocas banderas, y así el CLI no arrastra ninguna dependencia. */
 export declare function parseArgs(argv: readonly string[]): ParsedArgs;

package/dist/cli/args.js

@@ -1,18 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseArgs = parseArgs;
-/** Analizador de argumentos propio: son cuatro banderas, y así el CLI no arrastra ninguna dependencia. */
+/** Analizador de argumentos propio: son pocas banderas, y así el CLI no arrastra ninguna dependencia. */
 function parseArgs(argv) {
     const [command = null, ...rest] = argv;
-    const result = { command, dryRun: false, lockfile: null, app: null, origin: null, unknown: [] };
+    const esEnv = command === 'env';
+    const result = { command, dryRun: false, send: false, lockfile: null, app: null, origin: null, central: null, write: false, force: false, unknown: [] };
     for (let i = 0; i < rest.length; i++) {
         const arg = rest[i];
         if (arg === '--dry-run')
             result.dryRun = true;
-        else if (arg === '--lockfile' || arg === '--app' || arg === '--origin') {
+        else if (arg === '--send')
+            result.send = true;
+        else if (esEnv && arg === '--write')
+            result.write = true;
+        else if (esEnv && arg === '--force')
+            result.force = true;
+        else if (esEnv && arg?.startsWith('--central='))
+            result.central = arg.slice('--central='.length) || null;
+        else if (arg === '--lockfile' || arg === '--app' || arg === '--origin' || (esEnv && arg === '--central')) {
             const value = rest[++i];
             if (value && !value.startsWith('--'))
-                result[arg === '--lockfile' ? 'lockfile' : arg === '--app' ? 'app' : 'origin'] = value;
+                result[arg === '--lockfile' ? 'lockfile' : arg === '--app' ? 'app' : arg === '--central' ? 'central' : 'origin'] = value;
             else
                 result.unknown.push(`${arg} ${value ?? ''}`.trim());
         }

package/dist/cli/check.d.ts

@@ -15,6 +15,9 @@ export interface CheckResult {
  * - el módulo sin `app.use(growTicketsMiddleware(app))` en `main.ts`: sin él no se corta ninguna IP, no hay
  *   ruta de salud y no se cuenta lo que no casó con ninguna ruta;
  * - Express sin subir el tope de JSON: su parser corta en 100 KB y el contrato del portal es de 256 KB;
- * - un prefijo global con la ruta de serie: el portal quedaría en `/api/api/soporte`.
+ * - un prefijo global con la ruta de serie: el portal quedaría en `/api/api/soporte`;
+ * - las variables de entorno desde la central (`GROWTICKETS_ENV_KEY`): sin `loadGrowTicketsEnv()` en `main.ts`, o llamada después de
+ *   `NestFactory.create`, o sin el middleware, o sin `.growtickets/` en el `.gitignore`, no llegan, no llegan a tiempo, no se avisan al
+ *   instante o dejan la copia cifrada a un `git add` de distancia.
  */
 export declare function runCheck(cwd: string): CheckResult;

package/dist/cli/check.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCheck = runCheck;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const transport_1 = require("../env/transport");
 const env_example_1 = require("./env-example");
 const SOURCE_ROOTS = ['src', 'apps', 'libs'];
 const SCAN_EXTENSIONS = new Set(['.ts', '.js', '.mts', '.cts', '.mjs', '.cjs']);
@@ -14,6 +15,9 @@ const USES_MIDDLEWARE = /\bgrowTicketsMiddleware\s*\(/;
 const USES_FASTIFY = /\bFastifyAdapter\b/;
 const RAISES_JSON_LIMIT = /useBodyParser\s*\(\s*['"]json['"][^)]*limit/;
 const GLOBAL_PREFIX = /\bsetGlobalPrefix\s*\(\s*['"`]\/?([^'"`]+)['"`]/;
+const LOADS_ENV = /\bloadGrowTicketsEnv\s*\(/;
+const MENTIONS_ENV_KEY = new RegExp(`\\b(${transport_1.ENV_CREDENTIAL_VARIABLES.join('|')})\\b`);
+const CREATES_APP = /\bNestFactory\s*\.\s*create\w*\s*[(<]/;
 /**
  * De sólo lectura: nunca escribe nada, y por eso sirve para el CI del propio producto. Sale con 1 si
  * encuentra una vía por la que la clave acabe versionada (un `.gitignore` que no cubre `.env`, un
@@ -23,11 +27,14 @@ const GLOBAL_PREFIX = /\bsetGlobalPrefix\s*\(\s*['"`]\/?([^'"`]+)['"`]/;
  * - el módulo sin `app.use(growTicketsMiddleware(app))` en `main.ts`: sin él no se corta ninguna IP, no hay
  *   ruta de salud y no se cuenta lo que no casó con ninguna ruta;
  * - Express sin subir el tope de JSON: su parser corta en 100 KB y el contrato del portal es de 256 KB;
- * - un prefijo global con la ruta de serie: el portal quedaría en `/api/api/soporte`.
+ * - un prefijo global con la ruta de serie: el portal quedaría en `/api/api/soporte`;
+ * - las variables de entorno desde la central (`GROWTICKETS_ENV_KEY`): sin `loadGrowTicketsEnv()` en `main.ts`, o llamada después de
+ *   `NestFactory.create`, o sin el middleware, o sin `.growtickets/` en el `.gitignore`, no llegan, no llegan a tiempo, no se avisan al
+ *   instante o dejan la copia cifrada a un `git add` de distancia.
  */
 function runCheck(cwd) {
     const issues = [...checkGitignore(cwd), ...checkEnvExample(cwd)];
-    const warnings = checkWiring(cwd);
+    const warnings = [...checkWiring(cwd), ...checkEnvWiring(cwd)];
     return {
         exitCode: issues.length > 0 ? 1 : 0,
         issues,
@@ -71,6 +78,44 @@ function checkWiring(cwd) {
     }
     return warnings;
 }
+/**
+ * Las variables de entorno desde la central. Sólo avisa si el producto dice usarlas (nombra `GROWTICKETS_ENV_KEY` en su `.env.example` o en
+ * el código, o ya llama a `loadGrowTicketsEnv`): sin ello no hay nada que revisar.
+ */
+function checkEnvWiring(cwd) {
+    let carga = false;
+    let menciona = false;
+    let usaMiddleware = false;
+    let tardia = false;
+    for (const root of SOURCE_ROOTS) {
+        walk((0, node_path_1.join)(cwd, root), 0, (_path, content) => {
+            const llamada = content.search(LOADS_ENV);
+            const app = content.search(CREATES_APP);
+            carga ||= llamada >= 0;
+            menciona ||= MENTIONS_ENV_KEY.test(content);
+            usaMiddleware ||= USES_MIDDLEWARE.test(content);
+            tardia ||= llamada >= 0 && app >= 0 && llamada > app;
+        });
+    }
+    const ejemplo = (0, node_path_1.join)(cwd, '.env.example');
+    const declarada = menciona || ((0, node_fs_1.existsSync)(ejemplo) && MENTIONS_ENV_KEY.test((0, node_fs_1.readFileSync)(ejemplo, 'utf8')));
+    if (!declarada && !carga)
+        return [];
+    const warnings = [];
+    if (!carga) {
+        warnings.push(`${transport_1.ENV_CREDENTIAL_VARIABLES.join(', ')} está declarada pero ningún archivo llama a loadGrowTicketsEnv(): las variables de la central no llegan al proceso. Añade await loadGrowTicketsEnv() en main.ts, antes de NestFactory.create.`);
+        return warnings;
+    }
+    if (tardia)
+        warnings.push('loadGrowTicketsEnv() se llama DESPUÉS de NestFactory.create: ConfigModule y los providers ya leyeron el entorno. Pásala antes.');
+    if (!usaMiddleware)
+        warnings.push('loadGrowTicketsEnv() sin app.use(growTicketsMiddleware(app)): el aviso de «Vincular» no tiene dónde llegar y cada réplica se entera hasta un minuto después, por su revisión.');
+    const gitignore = (0, node_path_1.join)(cwd, '.gitignore');
+    if (!(0, node_fs_1.existsSync)(gitignore) || !(0, node_fs_1.readFileSync)(gitignore, 'utf8').split('\n').some((linea) => /^\/?\.growtickets\/?\*?$/.test(linea.trim()))) {
+        warnings.push('.gitignore no cubre .growtickets/: ahí queda la copia local cifrada de las variables. Cifrada no es pública: no la versiones.');
+    }
+    return warnings;
+}
 /** ¿La llamada a `forRoot`/`forRootAsync` le da su propia `path`? Se mira el trozo de texto justo después de la llamada. */
 function passesPath(content) {
     const inicio = content.search(USES_MODULE);

package/dist/cli/env-example.js

@@ -22,7 +22,24 @@ exports.PUBLIC_KEYS = [
     'GROWTICKETS_SECURITY_HEALTH_PATH',
     'GROWTICKETS_SECURITY_DEPENDENCIES',
     'GROWTICKETS_TRUSTED_PROXY_HOPS',
+    'GROWTICKETS_TRUST_REAL_IP',
     'GROWTICKETS_FRONT_DEPS_PATH',
+    'GROWTICKETS_SECURITY_CSP',
+    'GROWTICKETS_ORIGIN',
+    'GROWTICKETS_ENV_PATH',
+    'GROWTICKETS_ENV_ON_FAILURE',
+    'GROWTICKETS_ENV_MAX_STALE_HOURS',
+    'GROWTICKETS_ENV_ON_CHANGE',
+    'GROWTICKETS_ENV_EXIT_CODE',
+    'GROWTICKETS_ENV_DIR',
+    'GROWTICKETS_MAINTENANCE',
+    'GROWTICKETS_MAINTENANCE_HOST',
+    'GROWTICKETS_MAINTENANCE_PATH',
+    'GROWTICKETS_LOGS',
+    'GROWTICKETS_LOGS_LEVEL',
+    'GROWTICKETS_LOGS_ORIGIN',
+    'GROWTICKETS_LOGS_REDACT_KEYS',
+    'GROWTICKETS_LOGS_REQUESTS',
 ];
 /**
  * Sólo AÑADE lo que falte, y con valor VACÍO — nunca sobrescribe una clave que