@growconnect/growtickets-nest 0.1.0 → 0.3.0

package/dist/env/transport/client.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvClient = void 0;
+const node_crypto_1 = require("node:crypto");
+const sdk_1 = require("../../security/sdk");
+const errors_1 = require("../errors");
+const policy_1 = require("../policy");
+const config_1 = require("./config");
+const protocol_1 = require("./protocol");
+const MAX_BYTES = 8 * 1024 * 1024;
+const MAX_ERROR_BYTES = 64 * 1024;
+const CONNECT_TIMEOUT_MS = 3000;
+const TOTAL_TIMEOUT_MS = 10_000;
+const ACK_TIMEOUT_MS = 5000;
+const ATTEMPTS = 3;
+const RETRY_DELAY_MS = 300;
+/**
+ * Lo que habla con la central (protocolo GT-ENV2): bajar las variables de ESTE servidor (`GET api/ingest/env`) y confirmar que se aplicaron
+ * (`POST api/ingest/env/ack`). Ninguna clave viaja: cada petición va FIRMADA con la llave del servidor (`EnvCredential`) y cada respuesta se
+ * cree sólo si la firmó la central FIJADA en la credencial.
+ *
+ * - **Cifrado de punta a punta**: al bajar se manda una efímera X25519 nueva (firmada dentro de la petición) y la central cifra para ella. Sólo
+ *   este proceso puede abrir la respuesta, y la efímera se borra al salir: capturar el tráfico —o robar luego la credencial— no descifra nada.
+ * - **Sólo lo firmado cambia el estado**: un 304, un «revocada» o un error sin la firma de la central son `unsigned_response` (un fallo
+ *   pasajero: se sigue con la copia), y un 200 sin cifrar no se acepta aunque venga firmado.
+ * - **Sólo https** (salvo `localhost`, `127.0.0.1` y nombres `.test`/`.localhost`), **sin redirecciones** (`redirect: 'error'`), **tiempos y
+ *   tamaño con tope** (3 s hasta la respuesta, 10 s en total, 8 MB) y hasta tres intentos si la central no contestó o dio 5xx: cada uno con su
+ *   hora, su nonce y su efímera, porque repetir la misma petición sería un `replayed`.
+ * - **Errores con CÓDIGO** (`invalid_key`, `revoked_key`, `expired_key`, `no_environment`, `not_published`, `clock_skew`, `replayed`,
+ *   `network_not_allowed`, `unsigned_response`, `unreachable`, `timeout`, `malformed`, `incompatible_schema`), nunca con un valor ni con la
+ *   credencial.
+ *
+ * Cada petición dice quién pregunta —la réplica, la dirección del producto, la ruta por la que escucha avisos, la librería y el runtime— y
+ * esas cabeceras van DENTRO de la firma: la central las guarda y las usa.
+ */
+class EnvClient {
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** La versión vigente, o `null` si la central dice (firmado) que no cambió: 304 con el `etag` de la copia. */
+    async fetch(etag) {
+        const limpio = etag && (0, protocol_1.validEtag)(etag) ? etag : '';
+        const respuesta = await this.call('pull', '', limpio, TOTAL_TIMEOUT_MS, MAX_BYTES);
+        try {
+            return this.delivered(respuesta);
+        }
+        finally {
+            respuesta.ephemeral?.secret.fill(0);
+        }
+    }
+    /** Confirma a la central que esta réplica aplicó (o por qué no). Nunca lanza: un acuse perdido sólo deja el panel atrás. */
+    async ack(version, ok, errorCode) {
+        const cuerpo = ok ? { version, status: 'ok' } : { version, status: 'error', error_code: cleanCode(errorCode) };
+        try {
+            const respuesta = await this.call('ack', JSON.stringify(cuerpo), '', ACK_TIMEOUT_MS, MAX_ERROR_BYTES, 1);
+            return respuesta.status >= 200 && respuesta.status < 300 && this.signed(respuesta);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Lo que entregó la central, si lo FIRMÓ ella para esta petición.
+     *
+     * @throws EnvError
+     */
+    delivered(respuesta) {
+        if (!this.signed(respuesta)) {
+            throw new errors_1.EnvError('unsigned_response', `La central contestó ${respuesta.status} sin su firma (o la de otra central): revisa GROWTICKETS_URL. Se sigue con la copia local.`);
+        }
+        if (respuesta.status === 304)
+            return null;
+        const texto = respuesta.body.toString('utf8');
+        if (respuesta.status === 200) {
+            const claro = (0, protocol_1.open)(texto, this.deps.credential().keyId(), respuesta.hash, respuesta.ephemeral?.secret ?? Buffer.alloc(0));
+            if (claro === null)
+                throw new errors_1.EnvError('malformed', 'La respuesta de la central no se pudo descifrar.');
+            const datos = parseJson(claro);
+            return (0, policy_1.parseEnvPayload)(typeof datos === 'object' && datos !== null && !Array.isArray(datos) ? { ...datos, schema: policy_1.ENV_SCHEMA } : null, cleanEtag(respuesta.headers.get('etag')));
+        }
+        throw failure(respuesta.status, texto);
+    }
+    /** ¿La firmó la central fijada, para ESTA petición (su hash), con este estado, este cuerpo y este ETag? */
+    signed(respuesta) {
+        const credencial = this.deps.credential();
+        const cadena = (0, protocol_1.responseString)(respuesta.status, credencial.keyId(), respuesta.hash, respuesta.body, respuesta.headers.get('etag') ?? '');
+        return credencial.signedByCentral(cadena, respuesta.headers.get(protocol_1.SIGNATURE_HEADER) ?? '');
+    }
+    async call(operation, body, etag, totalMs, maxBytes, attempts = ATTEMPTS) {
+        const ajustes = this.deps.config();
+        if (ajustes.baseUrl === '')
+            throw new errors_1.EnvError('invalid_url', 'Falta GROWTICKETS_URL: la dirección de tu GrowTickets.');
+        if (!(0, config_1.isSecureUrl)(ajustes.baseUrl))
+            throw new errors_1.EnvError('insecure_url', 'GROWTICKETS_URL tiene que ser https: por ahí viajan los secretos.');
+        const credencial = this.deps.credential();
+        const url = `${ajustes.baseUrl}/api/ingest/${operation === 'pull' ? 'env' : 'env/ack'}`;
+        let ultimo = null;
+        for (let intento = 1; intento <= attempts; intento++) {
+            const efimera = operation === 'pull' ? (0, protocol_1.ephemeralFrom)(this.random(32)) : null;
+            const firmada = this.sign(credencial, ajustes, operation, body, etag, efimera);
+            try {
+                const respuesta = await this.once(url, { method: operation === 'pull' ? 'GET' : 'POST', headers: firmada.headers, body: operation === 'ack' ? body : undefined }, totalMs, maxBytes);
+                const entera = { ...respuesta, hash: firmada.hash, ephemeral: efimera };
+                if (respuesta.status < 500 || intento === attempts)
+                    return entera;
+                efimera?.secret.fill(0);
+                ultimo = new errors_1.EnvError('unreachable', `La central contestó ${respuesta.status}.`);
+            }
+            catch (error) {
+                efimera?.secret.fill(0);
+                if (!(error instanceof errors_1.EnvError) || error.reason === 'malformed')
+                    throw error;
+                ultimo = error;
+            }
+            await (this.deps.sleep ?? delay)(RETRY_DELAY_MS * intento);
+        }
+        throw ultimo ?? new errors_1.EnvError('unreachable', 'No se pudo llegar a la central.');
+    }
+    /** Las cabeceras de UNA petición firmada y el hash de su cadena. Cada intento llama otra vez: hora, nonce y efímera nuevos. */
+    sign(credencial, ajustes, operation, body, etag, efimera) {
+        const audiencia = (0, protocol_1.audience)(ajustes.baseUrl) ?? '';
+        const origen = ajustes.origin ?? this.deps.learnedOrigin?.() ?? '';
+        const identidad = [(0, sdk_1.instanceId)(this.deps.env()), origen, ajustes.path, `${sdk_1.SDK_NAME}/${sdk_1.SDK_VERSION}`, (0, sdk_1.runtimeHeader)()];
+        const hora = String(this.deps.now ? this.deps.now() : Math.floor(Date.now() / 1000));
+        const nonce = (0, protocol_1.b64u)(this.random(protocol_1.NONCE_BYTES));
+        const publicaEfimera = efimera ? (0, protocol_1.b64u)(efimera.public) : '';
+        const cadena = (0, protocol_1.requestString)(audiencia, operation, credencial.keyId(), hora, nonce, publicaEfimera, etag, body, (0, protocol_1.meta)(identidad));
+        const cabeceras = {
+            [protocol_1.KEY_HEADER]: credencial.keyId(),
+            [protocol_1.TIMESTAMP_HEADER]: hora,
+            [protocol_1.NONCE_HEADER]: nonce,
+            [protocol_1.EPHEMERAL_HEADER]: publicaEfimera,
+            'If-None-Match': etag,
+            [protocol_1.SIGNATURE_HEADER]: credencial.sign(cadena),
+            ...Object.fromEntries(protocol_1.META_HEADERS.map((nombre, i) => [nombre, identidad[i] ?? ''])),
+            ...(operation === 'ack' ? { 'Content-Type': 'application/json' } : {}),
+            Accept: 'application/json',
+        };
+        return { headers: Object.fromEntries(Object.entries(cabeceras).filter(([, valor]) => valor !== '')), hash: (0, protocol_1.requestHash)(cadena) };
+    }
+    async once(url, init, totalMs, maxBytes) {
+        const controller = new AbortController();
+        let motivo = null;
+        const total = setTimeout(() => {
+            motivo ??= 'total';
+            controller.abort();
+        }, totalMs);
+        const conexion = setTimeout(() => {
+            motivo ??= 'connect';
+            controller.abort();
+        }, CONNECT_TIMEOUT_MS);
+        try {
+            const respuesta = await (this.deps.fetchImpl ?? globalThis.fetch)(url, { ...init, signal: controller.signal, redirect: 'error' });
+            clearTimeout(conexion);
+            return { status: respuesta.status, headers: respuesta.headers, body: await readCapped(respuesta, maxBytes) };
+        }
+        catch (error) {
+            if (error instanceof errors_1.EnvError)
+                throw error;
+            throw motivo ? new errors_1.EnvError('timeout', 'La central tardó demasiado en contestar.') : new errors_1.EnvError('unreachable', 'No se pudo llegar a la central.');
+        }
+        finally {
+            clearTimeout(conexion);
+            clearTimeout(total);
+        }
+    }
+    random(bytes) {
+        return this.deps.random ? this.deps.random(bytes) : (0, node_crypto_1.randomBytes)(bytes);
+    }
+}
+exports.EnvClient = EnvClient;
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Lee el cuerpo hasta `max` bytes y, pasado el tope, DEJA de leer y lo da por malformado: una central comprometida (o un intermediario) no
+ * consigue que se siga consumiendo memoria. Con `content-length` a la vista se rechaza sin leer nada. Devuelve los BYTES: la firma de la
+ * respuesta es sobre ellos, y pasar por texto cambiaría los que no sean UTF-8.
+ */
+async function readCapped(respuesta, max) {
+    const declarado = Number(respuesta.headers.get('content-length') ?? '0');
+    if (Number.isFinite(declarado) && declarado > max)
+        throw new errors_1.EnvError('malformed', 'La respuesta de la central es demasiado grande.');
+    const lector = respuesta.body?.getReader();
+    if (!lector)
+        return Buffer.alloc(0);
+    const partes = [];
+    let total = 0;
+    for (;;) {
+        const { done, value } = await lector.read();
+        if (done)
+            break;
+        total += value.byteLength;
+        if (total > max) {
+            void lector.cancel().catch(() => undefined);
+            throw new errors_1.EnvError('malformed', 'La respuesta de la central es demasiado grande.');
+        }
+        partes.push(value);
+    }
+    return Buffer.concat(partes);
+}
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new errors_1.EnvError('malformed', 'La central contestó algo que no son variables de entorno.');
+    }
+}
+/** El error de una respuesta FIRMADA que no es ni 200 ni 304, con el código que la central dio cuando es uno de los conocidos. */
+function failure(status, text) {
+    const cuerpo = safeJson(text);
+    const codigo = typeof cuerpo.code === 'string' ? cuerpo.code : '';
+    const mensaje = typeof cuerpo.message === 'string' ? printable(cuerpo.message) : '';
+    if (status === 401 && ['revoked_key', 'expired_key', 'clock_skew', 'replayed'].includes(codigo))
+        return new errors_1.EnvError(codigo, mensaje || 'La central ya no acepta esta credencial.');
+    if (status === 401)
+        return new errors_1.EnvError('invalid_key', 'La central no reconoce GROWTICKETS_ENV_KEY: cópiala de nuevo desde la pestaña «Entornos» o conecta el servidor otra vez.');
+    if (status === 403 && codigo === 'network_not_allowed')
+        return new errors_1.EnvError(codigo, 'La central no deja pedir las variables desde la red de este servidor: revisa la red permitida en la pestaña «Entornos».');
+    if (status === 409 && (codigo === 'no_environment' || codigo === 'not_published'))
+        return new errors_1.EnvError(codigo, mensaje || 'El entorno no tiene versión vinculada.');
+    if (status === 429)
+        return new errors_1.EnvError('rate_limited', 'La central pidió esperar: demasiadas preguntas seguidas.');
+    return new errors_1.EnvError('unreachable', `La central contestó ${status}.`);
+}
+/** Un texto de la central listo para un mensaje: sin caracteres de control (una línea falsa en el registro) y acotado. */
+function printable(text) {
+    return [...text]
+        .map((c) => (c.charCodeAt(0) < 32 || c.charCodeAt(0) === 127 ? ' ' : c))
+        .join('')
+        .slice(0, 200);
+}
+function safeJson(text) {
+    try {
+        const valor = JSON.parse(text);
+        return typeof valor === 'object' && valor !== null ? valor : {};
+    }
+    catch {
+        return {};
+    }
+}
+function cleanEtag(value) {
+    const limpio = (value ?? '').trim();
+    return limpio !== '' && (0, protocol_1.validEtag)(limpio) ? limpio : null;
+}
+function cleanCode(code) {
+    return /^[a-z_]{1,40}$/.test(code ?? '') ? code : 'apply_failed';
+}

package/dist/env/transport/config.d.ts

@@ -0,0 +1,20 @@
+type Env = Record<string, string | undefined>;
+export interface TransportConfig {
+    /** `GROWTICKETS_ENV_KEY`: la credencial de SERVIDOR (`gtk2.<semilla>.<pública de la central>`, 92 caracteres). Vacía = la pieza no hace nada. */
+    key: string;
+    /** `GROWTICKETS_URL` sin barra final, o `''` si falta. */
+    baseUrl: string;
+    /** `GROWTICKETS_ENV_PATH`, que la central guarda para saber por dónde avisar. */
+    path: string;
+    /** La dirección pública del producto (`GROWTICKETS_ORIGIN`), que la central cruza con el dominio elegido al conectar el servidor. */
+    origin: string | null;
+}
+/** Las variables de entorno donde el producto declara su credencial para la central: `check` las busca en el código y en `.env.example`. */
+export declare const ENV_CREDENTIAL_VARIABLES: readonly string[];
+/** Lo que el entorno dice de con qué y hacia dónde se habla con la central. NUNCA lanza: una dirección mal escrita se queda como está y el cliente se niega a usarla. */
+export declare function readTransportConfig(env: Env): TransportConfig;
+/** ¿Hay credencial en este entorno? Es lo único que el middleware y la CLI preguntan antes de crear nada. */
+export declare function envConfigured(env: Env): boolean;
+/** ¿Se puede hablar con esta dirección? https siempre; http sólo con un nombre de desarrollo que no sale de la máquina. */
+export declare function isSecureUrl(url: string): boolean;
+export {};

package/dist/env/transport/config.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENV_CREDENTIAL_VARIABLES = void 0;
+exports.readTransportConfig = readTransportConfig;
+exports.envConfigured = envConfigured;
+exports.isSecureUrl = isSecureUrl;
+const settings_1 = require("../settings");
+/** Las variables de entorno donde el producto declara su credencial para la central: `check` las busca en el código y en `.env.example`. */
+exports.ENV_CREDENTIAL_VARIABLES = ['GROWTICKETS_ENV_KEY'];
+const ORIGIN_SHAPE = /^https?:\/\/[^\s"'<>/][^\s"'<>]{0,253}$/i;
+/** Lo que el entorno dice de con qué y hacia dónde se habla con la central. NUNCA lanza: una dirección mal escrita se queda como está y el cliente se niega a usarla. */
+function readTransportConfig(env) {
+    const origen = (env.GROWTICKETS_ORIGIN ?? env.GROWTICKETS_LOGS_ORIGIN ?? '').trim();
+    return {
+        key: (env.GROWTICKETS_ENV_KEY ?? '').trim(),
+        baseUrl: (env.GROWTICKETS_URL ?? '').trim().replace(/\/+$/, ''),
+        path: (0, settings_1.readEnvSettings)(env).path,
+        origin: ORIGIN_SHAPE.test(origen) ? origen.replace(/\/+$/, '') : null,
+    };
+}
+/** ¿Hay credencial en este entorno? Es lo único que el middleware y la CLI preguntan antes de crear nada. */
+function envConfigured(env) {
+    return readTransportConfig(env).key !== '';
+}
+/** ¿Se puede hablar con esta dirección? https siempre; http sólo con un nombre de desarrollo que no sale de la máquina. */
+function isSecureUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return false;
+    }
+    const host = parsed.hostname.toLowerCase().replace(/^\[|\]$/g, '');
+    if (parsed.protocol === 'https:')
+        return host !== '';
+    return parsed.protocol === 'http:' && (host === 'localhost' || host === '127.0.0.1' || host === '::1' || host.endsWith('.test') || host.endsWith('.localhost'));
+}

package/dist/env/transport/credential.d.ts

@@ -0,0 +1,33 @@
+/**
+ * La credencial de SERVIDOR (`GROWTICKETS_ENV_KEY=gtk2.<semilla>.<pública de la central>`, 92 caracteres) que da «Conectar un servidor» en la
+ * pestaña «Entornos», o que arma `growtickets-nest env keygen` en el propio servidor.
+ *
+ * De ella sale todo lo de este servidor en el protocolo GT-ENV2:
+ *
+ * - su par Ed25519, con el que FIRMA cada petición (la privada nunca viaja; su `key_id` sí, es público);
+ * - la pública de la central, que queda FIJADA: sólo se cree una respuesta, un aviso o un reto firmados con ella, aunque alguien se ponga en
+ *   medio o cambie `GROWTICKETS_URL`;
+ * - por HKDF de la semilla, las llaves locales (la copia cifrada): cada una con su `info`, y ninguna sirve para firmar.
+ *
+ * El formato anterior (`gte_…`) ya no vale, y el error dice qué hacer en vez de «clave inválida». Nunca repite la credencial en un mensaje.
+ */
+export declare class EnvCredential {
+    private readonly seed;
+    private readonly secretKey;
+    readonly publicKey: Buffer;
+    /** La pública de la central FIJADA en la credencial. */
+    readonly centralKey: Buffer;
+    private constructor();
+    /** @throws EnvError `invalid_key`, con un mensaje que dice qué hacer y nunca la credencial. */
+    static parse(text: string): EnvCredential;
+    /** ¿Tiene la forma de una credencial válida? Para el doctor: nunca lanza. */
+    static looksRight(text: string): boolean;
+    keyId(): string;
+    centralKid(): string;
+    /** Firma una cadena canónica con la llave de este servidor. */
+    sign(message: string): string;
+    /** ¿Lo firmó la central? Sólo cuenta la firma del kid FIJADO: otra llave, aunque la cabecera la traiga, no se prueba. */
+    signedByCentral(message: string, signatureHeader: string): boolean;
+    /** Una llave local de 32 bytes derivada de la semilla: cada `info` da otra distinta. */
+    derive(info: string): Buffer;
+}

package/dist/env/transport/credential.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvCredential = void 0;
+const node_crypto_1 = require("node:crypto");
+const errors_1 = require("../errors");
+const protocol_1 = require("./protocol");
+const SHAPE = /^gtk2\.([A-Za-z0-9_-]{43})\.([A-Za-z0-9_-]{43})$/;
+/**
+ * La credencial de SERVIDOR (`GROWTICKETS_ENV_KEY=gtk2.<semilla>.<pública de la central>`, 92 caracteres) que da «Conectar un servidor» en la
+ * pestaña «Entornos», o que arma `growtickets-nest env keygen` en el propio servidor.
+ *
+ * De ella sale todo lo de este servidor en el protocolo GT-ENV2:
+ *
+ * - su par Ed25519, con el que FIRMA cada petición (la privada nunca viaja; su `key_id` sí, es público);
+ * - la pública de la central, que queda FIJADA: sólo se cree una respuesta, un aviso o un reto firmados con ella, aunque alguien se ponga en
+ *   medio o cambie `GROWTICKETS_URL`;
+ * - por HKDF de la semilla, las llaves locales (la copia cifrada): cada una con su `info`, y ninguna sirve para firmar.
+ *
+ * El formato anterior (`gte_…`) ya no vale, y el error dice qué hacer en vez de «clave inválida». Nunca repite la credencial en un mensaje.
+ */
+class EnvCredential {
+    constructor(seed, secretKey, publicKey, 
+    /** La pública de la central FIJADA en la credencial. */
+    centralKey) {
+        this.seed = seed;
+        this.secretKey = secretKey;
+        this.publicKey = publicKey;
+        this.centralKey = centralKey;
+    }
+    /** @throws EnvError `invalid_key`, con un mensaje que dice qué hacer y nunca la credencial. */
+    static parse(text) {
+        if (text.startsWith('gte_')) {
+            throw new errors_1.EnvError('invalid_key', 'GROWTICKETS_ENV_KEY tiene el formato anterior (gte_): conecta el servidor de nuevo en la pestaña «Entornos» y pon la credencial nueva (gtk2.…).');
+        }
+        const forma = SHAPE.exec(text);
+        if (forma === null) {
+            throw new errors_1.EnvError('invalid_key', 'GROWTICKETS_ENV_KEY no tiene la forma de una credencial de servidor (gtk2.…, 92 caracteres): cópiala entera de la pestaña «Entornos».');
+        }
+        const semilla = (0, protocol_1.fromB64u)(forma[1], protocol_1.KEY_BYTES);
+        const central = (0, protocol_1.fromB64u)(forma[2], protocol_1.KEY_BYTES);
+        if (semilla === null || central === null || !(0, protocol_1.validPublicKey)(central)) {
+            throw new errors_1.EnvError('invalid_key', 'GROWTICKETS_ENV_KEY está dañada (algún carácter cambió al copiarla): cópiala de nuevo o rota la del servidor.');
+        }
+        const { secretKey, publicKey } = (0, protocol_1.edKeysFromSeed)(semilla);
+        return new EnvCredential(semilla, secretKey, publicKey, central);
+    }
+    /** ¿Tiene la forma de una credencial válida? Para el doctor: nunca lanza. */
+    static looksRight(text) {
+        try {
+            EnvCredential.parse(text);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    keyId() {
+        return (0, protocol_1.keyId)(this.publicKey);
+    }
+    centralKid() {
+        return (0, protocol_1.keyId)(this.centralKey);
+    }
+    /** Firma una cadena canónica con la llave de este servidor. */
+    sign(message) {
+        return (0, protocol_1.sign)(message, this.secretKey);
+    }
+    /** ¿Lo firmó la central? Sólo cuenta la firma del kid FIJADO: otra llave, aunque la cabecera la traiga, no se prueba. */
+    signedByCentral(message, signatureHeader) {
+        return (0, protocol_1.verifyHeader)(message, signatureHeader, this.centralKey);
+    }
+    /** Una llave local de 32 bytes derivada de la semilla: cada `info` da otra distinta. */
+    derive(info) {
+        return Buffer.from((0, node_crypto_1.hkdfSync)('sha256', this.seed, Buffer.alloc(0), Buffer.from(info, 'utf8'), protocol_1.KEY_BYTES));
+    }
+}
+exports.EnvCredential = EnvCredential;

package/dist/env/transport/gt2-transport.d.ts

@@ -0,0 +1,53 @@
+import type { EnvPayload } from '../policy';
+import { EnvCredential } from './credential';
+import { NonceCache } from './nonce-cache';
+import type { EnvTransport, IdentityRequest, IdentityVerdict, PushRequest, PushVerdict, TransportCheck } from './types';
+type Env = Record<string, string | undefined>;
+export interface Gt2TransportDeps {
+    env: () => Env;
+    fetchImpl?: typeof fetch;
+    /** La última dirección pública que vio la seguridad, para cuando `GROWTICKETS_ORIGIN` no la fija. */
+    learnedOrigin?: () => string | null;
+    sleep?: (ms: number) => Promise<void>;
+    /** Segundos, época Unix; las pruebas lo mueven. */
+    now?: () => number;
+    /** Las pruebas fijan nonces y efímeras para casar con el vector común. */
+    random?: (bytes: number) => Buffer;
+}
+/**
+ * El transporte GT-ENV2: se autentica FIRMANDO cada petición con la llave del servidor (la semilla de `GROWTICKETS_ENV_KEY`), cree sólo lo que
+ * firma la central FIJADA en esa credencial y recibe las variables CIFRADAS para cada petición. Ninguna clave viaja.
+ *
+ * ## El aviso y el reto
+ *
+ * Los dos los firma la central y sólo se atienden si la firma es suya, para ESTE `key_id`, con hora reciente y un nonce de un solo uso. La firma
+ * se comprueba ANTES de anotar el nonce, para que quien no la tenga no pueda llenar la memoria. El aviso trae `{"version": N}` y ningún valor; el
+ * reto se contesta firmando con la llave del servidor lo que demuestra que detrás de este dominio está esta credencial. Cualquier otra cosa es
+ * un 404 mudo. Los nonce viven en la memoria de este proceso (ver `NonceCache`).
+ */
+export declare class Gt2EnvTransport implements EnvTransport {
+    private readonly deps;
+    readonly pushOperation = "apply";
+    readonly identityOperation = "identity";
+    readonly maxPushBodyBytes = 256;
+    readonly nonces: NonceCache;
+    private readonly client;
+    private parsed;
+    constructor(deps: Gt2TransportDeps);
+    configured(): boolean;
+    diagnose(): TransportCheck[];
+    fetch(etag?: string | null): Promise<EnvPayload | null>;
+    ack(version: number, ok: boolean, errorCode?: string | null): Promise<boolean>;
+    verifyPush(request: PushRequest): PushVerdict;
+    verifyIdentity(request: IdentityRequest): IdentityVerdict;
+    snapshotKey(): Buffer | null;
+    /** La credencial de este entorno; la parsea una vez por valor. @throws EnvError `invalid_key` */
+    credential(): EnvCredential;
+    private credentialOrNull;
+    /** Lo común de un aviso y un reto: es para ESTE servidor, la hora es reciente y el nonce tiene su forma. */
+    private fresh;
+    /** El host de la petición o el de la dirección pública del producto: detrás de un proxy uno de los dos es el que la central pidió. */
+    private hostCandidates;
+    private config;
+}
+export {};

package/dist/env/transport/gt2-transport.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gt2EnvTransport = void 0;
+const errors_1 = require("../errors");
+const client_1 = require("./client");
+const config_1 = require("./config");
+const credential_1 = require("./credential");
+const nonce_cache_1 = require("./nonce-cache");
+const protocol_1 = require("./protocol");
+const PUSH_OPERATION = 'apply';
+const IDENTITY_OPERATION = 'identity';
+const MAX_PUSH_BODY_BYTES = 256;
+const SNAPSHOT_INFO = 'growtickets-env-snapshot';
+const OFF_HINT = 'Está apagada: falta GROWTICKETS_ENV_KEY (la da «Conectar un servidor» en la pestaña «Entornos» del proyecto).';
+/**
+ * El transporte GT-ENV2: se autentica FIRMANDO cada petición con la llave del servidor (la semilla de `GROWTICKETS_ENV_KEY`), cree sólo lo que
+ * firma la central FIJADA en esa credencial y recibe las variables CIFRADAS para cada petición. Ninguna clave viaja.
+ *
+ * ## El aviso y el reto
+ *
+ * Los dos los firma la central y sólo se atienden si la firma es suya, para ESTE `key_id`, con hora reciente y un nonce de un solo uso. La firma
+ * se comprueba ANTES de anotar el nonce, para que quien no la tenga no pueda llenar la memoria. El aviso trae `{"version": N}` y ningún valor; el
+ * reto se contesta firmando con la llave del servidor lo que demuestra que detrás de este dominio está esta credencial. Cualquier otra cosa es
+ * un 404 mudo. Los nonce viven en la memoria de este proceso (ver `NonceCache`).
+ */
+class Gt2EnvTransport {
+    constructor(deps) {
+        this.deps = deps;
+        this.pushOperation = PUSH_OPERATION;
+        this.identityOperation = IDENTITY_OPERATION;
+        this.maxPushBodyBytes = MAX_PUSH_BODY_BYTES;
+        this.nonces = new nonce_cache_1.NonceCache();
+        this.parsed = null;
+        this.client = new client_1.EnvClient({
+            credential: () => this.credential(),
+            config: () => this.config(),
+            env: deps.env,
+            fetchImpl: deps.fetchImpl,
+            learnedOrigin: deps.learnedOrigin,
+            sleep: deps.sleep,
+            now: deps.now,
+            random: deps.random,
+        });
+    }
+    configured() {
+        return this.config().key !== '';
+    }
+    diagnose() {
+        const config = this.config();
+        if (config.key === '')
+            return [{ level: 'warn', text: OFF_HINT }];
+        let clave;
+        try {
+            clave = { level: 'ok', text: `La credencial tiene forma de credencial de servidor (key_id ${this.credential().keyId()}, el mismo que enseña el panel)` };
+        }
+        catch (error) {
+            clave = { level: 'fail', text: error instanceof errors_1.EnvError ? error.message : 'GROWTICKETS_ENV_KEY no es válida.' };
+        }
+        if (config.baseUrl === '')
+            return [clave, { level: 'fail', text: 'Falta GROWTICKETS_URL: la dirección de tu GrowTickets.' }];
+        return [
+            clave,
+            (0, config_1.isSecureUrl)(config.baseUrl)
+                ? { level: 'ok', text: 'GROWTICKETS_URL usa https' }
+                : { level: 'fail', text: 'GROWTICKETS_URL tiene que ser https (o localhost en desarrollo): por ahí viajan los secretos.' },
+        ];
+    }
+    fetch(etag) {
+        return this.client.fetch(etag);
+    }
+    ack(version, ok, errorCode) {
+        return this.client.ack(version, ok, errorCode);
+    }
+    verifyPush(request) {
+        const rechazado = { status: 'rejected' };
+        if (request.method !== 'POST' || request.query !== '' || request.body === null || Buffer.byteLength(request.body, 'utf8') > MAX_PUSH_BODY_BYTES)
+            return rechazado;
+        const credencial = this.credentialOrNull();
+        if (credencial === null)
+            return rechazado;
+        const kid = request.header(protocol_1.KEY_HEADER.toLowerCase()) ?? '';
+        const hora = request.header(protocol_1.TIMESTAMP_HEADER.toLowerCase()) ?? '';
+        const nonce = request.header(protocol_1.NONCE_HEADER.toLowerCase()) ?? '';
+        if (!this.fresh(credencial, kid, hora, nonce, request.nowSeconds))
+            return rechazado;
+        if (!credencial.signedByCentral((0, protocol_1.pushString)(kid, hora, nonce, request.body), request.header(protocol_1.SIGNATURE_HEADER.toLowerCase()) ?? ''))
+            return rechazado;
+        if (!this.nonces.consume(`apply:${nonce}`, request.nowSeconds * 1000))
+            return rechazado;
+        const version = versionOf(request.body);
+        return version === null ? { status: 'invalid_body' } : { status: 'accepted', version };
+    }
+    verifyIdentity(request) {
+        const rechazado = { status: 'rejected' };
+        const credencial = this.credentialOrNull();
+        const reto = /^challenge=([A-Za-z0-9_-]{43})$/.exec(request.query)?.[1] ?? '';
+        if (credencial === null || request.method !== 'GET' || (0, protocol_1.fromB64u)(reto, protocol_1.KEY_BYTES) === null)
+            return rechazado;
+        const kid = request.header(protocol_1.KEY_HEADER.toLowerCase()) ?? '';
+        const hora = request.header(protocol_1.TIMESTAMP_HEADER.toLowerCase()) ?? '';
+        const nonce = request.header(protocol_1.NONCE_HEADER.toLowerCase()) ?? '';
+        if (!this.fresh(credencial, kid, hora, nonce, request.nowSeconds))
+            return rechazado;
+        const firma = request.header(protocol_1.SIGNATURE_HEADER.toLowerCase()) ?? '';
+        const host = this.hostCandidates(request.host).find((candidato) => credencial.signedByCentral((0, protocol_1.challengeString)(kid, candidato, reto, hora, nonce), firma));
+        if (host === undefined || !this.nonces.consume(`identity:${nonce}`, request.nowSeconds * 1000))
+            return rechazado;
+        const ahora = String(request.nowSeconds);
+        return { status: 'answer', body: { kid, public_key: (0, protocol_1.b64u)(credencial.publicKey), host, challenge: reto, ts: ahora, sig: credencial.sign((0, protocol_1.identityString)(kid, host, reto, ahora)) } };
+    }
+    snapshotKey() {
+        return this.credentialOrNull()?.derive(SNAPSHOT_INFO) ?? null;
+    }
+    /** La credencial de este entorno; la parsea una vez por valor. @throws EnvError `invalid_key` */
+    credential() {
+        const texto = this.config().key;
+        if (texto === '')
+            throw new errors_1.EnvError('invalid_key', 'Falta GROWTICKETS_ENV_KEY.');
+        if (this.parsed?.text !== texto)
+            this.parsed = { text: texto, credential: credential_1.EnvCredential.parse(texto) };
+        return this.parsed.credential;
+    }
+    credentialOrNull() {
+        try {
+            return this.credential();
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Lo común de un aviso y un reto: es para ESTE servidor, la hora es reciente y el nonce tiene su forma. */
+    fresh(credencial, kid, hora, nonce, ahora) {
+        return kid === credencial.keyId() && (0, protocol_1.validTimestamp)(hora) && Math.abs(ahora - Number(hora)) <= nonce_cache_1.TOLERANCE_SECONDS && (0, protocol_1.fromB64u)(nonce, protocol_1.NONCE_BYTES) !== null;
+    }
+    /** El host de la petición o el de la dirección pública del producto: detrás de un proxy uno de los dos es el que la central pidió. */
+    hostCandidates(host) {
+        const origen = this.config().origin ?? this.deps.learnedOrigin?.() ?? null;
+        let delOrigen = null;
+        try {
+            delOrigen = origen === null ? null : new URL(origen).hostname.toLowerCase();
+        }
+        catch {
+            delOrigen = null;
+        }
+        return [...new Set([host, delOrigen].filter((h) => h !== null && /^[a-z0-9.:[\]-]{1,253}$/.test(h)))];
+    }
+    config() {
+        return (0, config_1.readTransportConfig)(this.deps.env());
+    }
+}
+exports.Gt2EnvTransport = Gt2EnvTransport;
+function versionOf(cuerpo) {
+    try {
+        const datos = JSON.parse(cuerpo);
+        const version = typeof datos === 'object' && datos !== null ? datos.version : null;
+        const numero = typeof version === 'string' && /^\d{1,15}$/.test(version) ? Number(version) : version;
+        return typeof numero === 'number' && Number.isSafeInteger(numero) && numero >= 1 ? numero : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/env/transport/index.d.ts

@@ -0,0 +1,10 @@
+import { type Gt2TransportDeps } from './gt2-transport';
+import type { EnvTransport } from './types';
+export { ENV_CREDENTIAL_VARIABLES, envConfigured } from './config';
+export { Gt2EnvTransport } from './gt2-transport';
+export type { EnvTransport, IdentityRequest, IdentityVerdict, PushRequest, PushVerdict, TransportCheck } from './types';
+/**
+ * El transporte de ESTE protocolo con la central (GT-ENV2). Es el único punto de la pieza que sabe cómo se autentica, cómo se cifra y cómo se
+ * verifica un aviso o un reto: un protocolo nuevo se enchufa cambiando lo que devuelve esta función (o pasando otro `transport` a `EnvRuntime`).
+ */
+export declare function createEnvTransport(deps: Gt2TransportDeps): EnvTransport;