@pipeline-builder/api-core 4.1.2 → 4.1.4

package/lib/services/env-redis.js

@@ -4,91 +4,233 @@ import { createRequire } from 'module';
 import { createLogger } from '../utils/logger.js';
 const logger = createLogger('env-redis');
 /**
- * Parse `REDIS_SENTINELS` (comma-separated `host:port` list) into the ioredis
- * `{ host, port }[]` sentinel array. Blank/garbage entries are skipped; a
- * missing port defaults to the Sentinel default 26379. Returns an empty array
- * when the env is unset/empty (→ non-sentinel mode).
+ * The ONE place Redis connection settings are read from the environment.
+ *
+ * Two shapes, exactly one of which may be set:
+ *
+ * - **Standalone** — `REDIS_URL` (`redis://host:6379[/db]`, or `rediss://` for
+ *   TLS). Credentials may sit in the URL or in `REDIS_PASSWORD`.
+ * - **HA (Sentinel)** — `REDIS_SENTINELS` (comma-separated `host:port`) plus
+ *   `REDIS_SENTINEL_MASTER` (default `mymaster`) and optional
+ *   `REDIS_SENTINEL_PASSWORD`. `REDIS_PASSWORD` authenticates to the data nodes.
+ *   ioredis follows the master across a failover.
+ *
+ * Neither set → Redis is off, and each caller degrades to its documented
+ * no-Redis behavior.
+ *
+ * `REDIS_HOST` / `REDIS_PORT` are not read. `REDIS_HOST` is refused outright so a
+ * stale config fails at startup instead of silently running without Redis.
+ * `REDIS_PORT` can't be refused: Kubernetes injects `REDIS_PORT=tcp://<ip>:6379`
+ * into every pod in a namespace with a Service named `redis`, which is exactly
+ * why a host/port pair was unsafe to parse.
+ *
+ * Misconfiguration throws {@link RedisConfigError}. Writers and readers of the
+ * same keys (revocation, step-up, leader locks) must resolve Redis identically;
+ * a config that quietly resolved to "no Redis" on one side is how revocation
+ * once did nothing at all.
+ */
+/** Thrown for a Redis environment that can't be used as written. */
+export class RedisConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'RedisConfigError';
+    }
+}
+/**
+ * Parse `REDIS_SENTINELS` into `{ host, port }[]`. Blank entries are skipped and
+ * a missing port means the Sentinel default 26379; a port that isn't a valid
+ * TCP port is a configuration error.
  */
 export function parseSentinels(raw) {
     if (!raw)
         return [];
     return raw.split(',').map((s) => s.trim()).filter(Boolean).map((entry) => {
-        const [host, port] = entry.split(':');
-        return { host, port: parseInt(port ?? '26379', 10) || 26379 };
-    }).filter((s) => !!s.host);
+        const idx = entry.lastIndexOf(':');
+        const host = idx === -1 ? entry : entry.slice(0, idx);
+        const portText = idx === -1 ? '' : entry.slice(idx + 1);
+        const port = portText === '' ? 26379 : Number(portText);
+        if (!host || !Number.isInteger(port) || port < 1 || port > 65535) {
+            throw new RedisConfigError(`REDIS_SENTINELS entry "${entry}" is not host:port`);
+        }
+        return { host, port };
+    });
+}
+/**
+ * Resolve the Redis connection from `env`, or `null` when Redis isn't
+ * configured. Throws {@link RedisConfigError} for an unusable configuration.
+ */
+export function resolveRedisConnection(env = process.env) {
+    if (env.REDIS_HOST) {
+        throw new RedisConfigError('REDIS_HOST is not supported. Set REDIS_URL=redis://<host>:<port> (or REDIS_SENTINELS for HA) and remove REDIS_HOST/REDIS_PORT.');
+    }
+    const sentinels = parseSentinels(env.REDIS_SENTINELS);
+    const url = env.REDIS_URL?.trim();
+    const password = env.REDIS_PASSWORD || undefined;
+    if (sentinels.length > 0 && url) {
+        throw new RedisConfigError('Set REDIS_URL or REDIS_SENTINELS, not both.');
+    }
+    if (sentinels.length > 0) {
+        return {
+            mode: 'sentinel',
+            sentinels,
+            masterName: env.REDIS_SENTINEL_MASTER || 'mymaster',
+            password,
+            sentinelPassword: env.REDIS_SENTINEL_PASSWORD || undefined,
+        };
+    }
+    if (url) {
+        let parsed;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            throw new RedisConfigError('REDIS_URL is not a valid URL (expected redis://<host>:<port>).');
+        }
+        if (parsed.protocol !== 'redis:' && parsed.protocol !== 'rediss:') {
+            throw new RedisConfigError(`REDIS_URL must use redis:// or rediss://, got ${parsed.protocol}//`);
+        }
+        if (!parsed.hostname)
+            throw new RedisConfigError('REDIS_URL has no host.');
+        return { mode: 'url', url, password };
+    }
+    return null;
+}
+/** A log-safe description of a connection (never includes credentials). */
+export function describeRedisConnection(conn) {
+    if (conn.mode === 'sentinel') {
+        return { mode: 'sentinel', master: conn.masterName, sentinels: conn.sentinels.length };
+    }
+    const u = new URL(conn.url);
+    return { mode: 'url', host: u.hostname, port: u.port || '6379', tls: u.protocol === 'rediss:' };
+}
+function loadIoredis() {
+    const req = createRequire(import.meta.url);
+    const mod = req('ioredis');
+    return (mod.Redis ?? mod.default ?? mod);
 }
 /**
- * Construct an ioredis client from the standard `REDIS_URL` or
- * `REDIS_HOST`/`REDIS_PORT` env — OR, for HA, from Redis Sentinel via
- * `REDIS_SENTINELS` + `REDIS_SENTINEL_MASTER`. The shared construction was
- * previously duplicated across the leader-lock, audit-spool, and
- * token-revocation env factories.
+ * Construct an ioredis client for a resolved connection. `options` are merged
+ * into the client options (e.g. `{ db, maxRetriesPerRequest: null }` for BullMQ).
+ * An `error` listener is always attached so a dropped connection is logged
+ * rather than surfacing as an unhandled `'error'` event that crashes Node.
+ */
+export function createRedisClient(conn, label, options = {}) {
+    const Ctor = loadIoredis();
+    const auth = conn.password ? { password: conn.password } : {};
+    const inst = conn.mode === 'sentinel'
+        ? new Ctor({
+            sentinels: conn.sentinels,
+            name: conn.masterName,
+            ...(conn.sentinelPassword ? { sentinelPassword: conn.sentinelPassword } : {}),
+            ...auth,
+            ...options,
+        })
+        : new Ctor(conn.url, { ...auth, ...options });
+    inst
+        .on('error', (e) => logger.warn(`Redis ${label} client error`, { error: e instanceof Error ? e.message : String(e) }));
+    return inst;
+}
+/**
+ * The shared application Redis client: `null` when Redis isn't configured, so
+ * the caller degrades to its no-Redis behavior.
  *
- * Connection modes (first that matches wins):
- * 1. SENTINEL — `REDIS_SENTINELS` set (comma-separated `host:port`): ioredis
- *    resolves the current master from the sentinels (`name` = `REDIS_SENTINEL_MASTER`,
- *    default `mymaster`) and transparently reconnects to the new master after a
- *    failover. This is how the app gets HA against a single-node Redis loss —
- *    also the shape a managed ElastiCache (cluster-mode-disabled) speaks.
- * 2. URL — `REDIS_URL`.
- * 3. HOST/PORT — `REDIS_HOST`(+`REDIS_PORT`).
+ * Commands fail fast (`maxRetriesPerRequest: 1`, no offline queue) because the
+ * request-path callers are best-effort or fail closed on their own terms — a
+ * request must not hang behind a Redis outage. That includes the moments before
+ * the first connection completes: a background caller that runs at startup must
+ * either tolerate a rejected command or wait with {@link whenRedisReady}.
  *
- * Semantics every caller relies on (kept identical across the consolidation):
- * - Returns `null` when NONE of sentinels/url/host is set, so a caller degrades
- *   to its no-Redis fallback (run-on-every-pod / best-effort / fail-open).
- * - FAIL-SAFE: any ioredis load or construction error is swallowed and returns
- *   `null` — Redis being unavailable must never crash the importing service.
- * - `ioredis` is a runtime-only optional dep loaded via `createRequire`, so this
- *   module stays importable in CJS bundles and where Redis isn't installed.
- * - `maxRetriesPerRequest: 1` + `enableOfflineQueue: false`: commands fail fast
- *   rather than queueing during an outage (callers are fail-open/best-effort).
- * - An `error` listener is attached (ioredis auto-reconnects) so a dropped
- *   connection can't surface as an unhandled `'error'` event that crashes Node.
+ * Throws {@link RedisConfigError} for a bad configuration, and if Redis is
+ * configured but `ioredis` can't be loaded — both are deployment errors that
+ * must not quietly turn Redis-backed guarantees off.
+ */
+export function createEnvRedisClient(label) {
+    const conn = resolveRedisConnection();
+    if (!conn)
+        return null;
+    const inst = createRedisClient(conn, label, { maxRetriesPerRequest: 1, enableOfflineQueue: false });
+    logger.info(`Redis ${label} client created`, describeRedisConnection(conn));
+    return inst;
+}
+/**
+ * Resolve once `client` is connected and ready for commands, or reject after
+ * `timeoutMs`. For startup work (creating a consumer group, subscribing) that
+ * otherwise races the first connection. A client without ioredis' `status`
+ * (e.g. a test double) counts as ready.
+ */
+export function whenRedisReady(client, timeoutMs = 30_000) {
+    if (client.status === undefined || client.status === 'ready' || !client.once)
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        const onReady = () => { clearTimeout(timer); resolve(); };
+        const timer = setTimeout(() => {
+            client.off?.('ready', onReady);
+            reject(new Error(`Redis not ready after ${timeoutMs}ms`));
+        }, timeoutMs);
+        timer.unref?.();
+        client.once('ready', onReady);
+    });
+}
+/** Default bound for {@link createRedisReadyGate}: short enough for a request path. */
+export const REQUEST_PATH_REDIS_READY_TIMEOUT_MS = 2_000;
+/**
+ * A request-path readiness gate for a lazily built env Redis client.
  *
- * Optional auth: `REDIS_PASSWORD` (data-node AUTH) and `REDIS_SENTINEL_PASSWORD`
- * (sentinel AUTH, sentinel mode only) are threaded through when set.
+ * The env client has no offline queue, so a command issued before the first
+ * connection completes is rejected outright — the first request after a lazy
+ * construction would otherwise hit that rejection (e.g. the first step-up per
+ * pod failing, or the first impersonation check reading "unavailable").
  *
- * @param label short human name for this client, used in the two warn logs.
+ * The returned function resolves once the client is ready, or after
+ * `timeoutMs` — it NEVER rejects: the caller then runs its command and keeps its
+ * own fail-open / fail-closed semantics. Concurrent callers share one wait. After
+ * a wait times out (Redis genuinely down) later calls stop waiting until the
+ * client reports `ready` again, so an outage costs one bounded wait instead of
+ * adding `timeoutMs` to every request.
  */
-export function createEnvRedisClient(label) {
-    try {
-        const sentinels = parseSentinels(process.env.REDIS_SENTINELS);
-        const url = process.env.REDIS_URL;
-        const host = process.env.REDIS_HOST;
-        if (sentinels.length === 0 && !url && !host)
-            return null;
-        const req = createRequire(import.meta.url);
-        const mod = req('ioredis');
-        const RedisCtor = (mod.Redis ?? mod.default ?? mod);
-        const redisOpts = { maxRetriesPerRequest: 1, enableOfflineQueue: false };
-        if (process.env.REDIS_PASSWORD)
-            redisOpts.password = process.env.REDIS_PASSWORD;
-        let inst;
-        if (sentinels.length > 0) {
-            // Sentinel mode: ioredis tracks the master via the sentinels + auto-fails-over.
-            const sentinelOpts = {
-                sentinels,
-                name: process.env.REDIS_SENTINEL_MASTER || 'mymaster',
-                ...redisOpts,
-            };
-            if (process.env.REDIS_SENTINEL_PASSWORD)
-                sentinelOpts.sentinelPassword = process.env.REDIS_SENTINEL_PASSWORD;
-            inst = new RedisCtor(sentinelOpts);
-            logger.info(`Redis ${label}: Sentinel mode`, { master: sentinelOpts.name, sentinels: sentinels.length });
-        }
-        else if (url) {
-            inst = new RedisCtor(url, redisOpts);
+export function createRedisReadyGate(client, timeoutMs = REQUEST_PATH_REDIS_READY_TIMEOUT_MS) {
+    let inflight = null;
+    let gaveUp = false;
+    return () => {
+        if (client.status === undefined || client.status === 'ready' || !client.once) {
+            gaveUp = false;
+            return Promise.resolve();
         }
-        else {
-            inst = new RedisCtor({ host, port: parseInt(process.env.REDIS_PORT ?? '6379', 10), ...redisOpts });
+        if (gaveUp)
+            return Promise.resolve();
+        if (!inflight) {
+            inflight = whenRedisReady(client, timeoutMs)
+                .catch(() => {
+                gaveUp = true;
+                // Re-arm the wait once the connection comes back.
+                client.once('ready', () => { gaveUp = false; });
+            })
+                .finally(() => { inflight = null; });
         }
-        inst
-            .on('error', (e) => logger.warn(`Redis ${label} client error`, { error: e instanceof Error ? e.message : String(e) }));
-        return inst;
-    }
-    catch (err) {
-        logger.warn(`Redis unavailable for ${label}`, { error: err instanceof Error ? err.message : String(err) });
-        return null;
-    }
+        return inflight;
+    };
+}
+/**
+ * INCR a fixed-window counter and make sure it carries a TTL, atomically.
+ *
+ * A separate `INCR` then `EXPIRE` is not atomic: if the EXPIRE is lost (a
+ * connection drop, a failover between the two commands) the key never expires
+ * and the counter stays over its limit forever. The script also heals a key
+ * that somehow lacks a TTL (`PTTL` = -1) rather than only setting it on the
+ * first hit.
+ */
+const INCR_WINDOW_SCRIPT = `
+local n = redis.call('INCR', KEYS[1])
+if n == 1 or redis.call('PTTL', KEYS[1]) < 0 then
+  redis.call('PEXPIRE', KEYS[1], ARGV[1])
+end
+return n`;
+/**
+ * Increment `key` within a window of `windowMs` and return the new count.
+ * Throws when Redis errors — callers choose their own failure policy.
+ */
+export async function incrWindow(redis, key, windowMs) {
+    const n = await redis.eval(INCR_WINDOW_SCRIPT, 1, key, Math.max(1, Math.ceil(windowMs)));
+    return Number(n);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"env-redis.js","sourceRoot":"","sources":["../../src/services/env-redis.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createRequire } from 'module';\n\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('env-redis');\n\n/**\n * Parse `REDIS_SENTINELS` (comma-separated `host:port` list) into the ioredis\n * `{ host, port }[]` sentinel array. Blank/garbage entries are skipped; a\n * missing port defaults to the Sentinel default 26379. Returns an empty array\n * when the env is unset/empty (→ non-sentinel mode).\n */\nexport function parseSentinels(raw: string | undefined): Array<{ host: string; port: number }> {\n  if (!raw) return [];\n  return raw.split(',').map((s) => s.trim()).filter(Boolean).map((entry) => {\n    const [host, port] = entry.split(':');\n    return { host, port: parseInt(port ?? '26379', 10) || 26379 };\n  }).filter((s) => !!s.host);\n}\n\n/**\n * Construct an ioredis client from the standard `REDIS_URL` or\n * `REDIS_HOST`/`REDIS_PORT` env — OR, for HA, from Redis Sentinel via\n * `REDIS_SENTINELS` + `REDIS_SENTINEL_MASTER`. The shared construction was\n * previously duplicated across the leader-lock, audit-spool, and\n * token-revocation env factories.\n *\n * Connection modes (first that matches wins):\n * 1. SENTINEL — `REDIS_SENTINELS` set (comma-separated `host:port`): ioredis\n *    resolves the current master from the sentinels (`name` = `REDIS_SENTINEL_MASTER`,\n *    default `mymaster`) and transparently reconnects to the new master after a\n *    failover. This is how the app gets HA against a single-node Redis loss —\n *    also the shape a managed ElastiCache (cluster-mode-disabled) speaks.\n * 2. URL — `REDIS_URL`.\n * 3. HOST/PORT — `REDIS_HOST`(+`REDIS_PORT`).\n *\n * Semantics every caller relies on (kept identical across the consolidation):\n * - Returns `null` when NONE of sentinels/url/host is set, so a caller degrades\n *   to its no-Redis fallback (run-on-every-pod / best-effort / fail-open).\n * - FAIL-SAFE: any ioredis load or construction error is swallowed and returns\n *   `null` — Redis being unavailable must never crash the importing service.\n * - `ioredis` is a runtime-only optional dep loaded via `createRequire`, so this\n *   module stays importable in CJS bundles and where Redis isn't installed.\n * - `maxRetriesPerRequest: 1` + `enableOfflineQueue: false`: commands fail fast\n *   rather than queueing during an outage (callers are fail-open/best-effort).\n * - An `error` listener is attached (ioredis auto-reconnects) so a dropped\n *   connection can't surface as an unhandled `'error'` event that crashes Node.\n *\n * Optional auth: `REDIS_PASSWORD` (data-node AUTH) and `REDIS_SENTINEL_PASSWORD`\n * (sentinel AUTH, sentinel mode only) are threaded through when set.\n *\n * @param label short human name for this client, used in the two warn logs.\n */\nexport function createEnvRedisClient<T = unknown>(label: string): T | null {\n  try {\n    const sentinels = parseSentinels(process.env.REDIS_SENTINELS);\n    const url = process.env.REDIS_URL;\n    const host = process.env.REDIS_HOST;\n    if (sentinels.length === 0 && !url && !host) return null;\n    const req = createRequire(import.meta.url);\n    const mod = req('ioredis') as {\n      Redis?: new (...args: unknown[]) => unknown;\n      default?: new (...args: unknown[]) => unknown;\n    };\n    const RedisCtor = (mod.Redis ?? mod.default ?? mod) as new (...args: unknown[]) => T;\n    const redisOpts: Record<string, unknown> = { maxRetriesPerRequest: 1, enableOfflineQueue: false };\n    if (process.env.REDIS_PASSWORD) redisOpts.password = process.env.REDIS_PASSWORD;\n\n    let inst: T;\n    if (sentinels.length > 0) {\n      // Sentinel mode: ioredis tracks the master via the sentinels + auto-fails-over.\n      const sentinelOpts: Record<string, unknown> = {\n        sentinels,\n        name: process.env.REDIS_SENTINEL_MASTER || 'mymaster',\n        ...redisOpts,\n      };\n      if (process.env.REDIS_SENTINEL_PASSWORD) sentinelOpts.sentinelPassword = process.env.REDIS_SENTINEL_PASSWORD;\n      inst = new RedisCtor(sentinelOpts);\n      logger.info(`Redis ${label}: Sentinel mode`, { master: sentinelOpts.name, sentinels: sentinels.length });\n    } else if (url) {\n      inst = new RedisCtor(url, redisOpts);\n    } else {\n      inst = new RedisCtor({ host, port: parseInt(process.env.REDIS_PORT ?? '6379', 10), ...redisOpts });\n    }\n    (inst as unknown as { on: (evt: string, cb: (e: unknown) => void) => void })\n      .on('error', (e) => logger.warn(`Redis ${label} client error`, { error: e instanceof Error ? e.message : String(e) }));\n    return inst;\n  } catch (err) {\n    logger.warn(`Redis unavailable for ${label}`, { error: err instanceof Error ? err.message : String(err) });\n    return null;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"env-redis.js","sourceRoot":"","sources":["../../src/services/env-redis.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createRequire } from 'module';\n\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('env-redis');\n\n/**\n * The ONE place Redis connection settings are read from the environment.\n *\n * Two shapes, exactly one of which may be set:\n *\n * - **Standalone** — `REDIS_URL` (`redis://host:6379[/db]`, or `rediss://` for\n *   TLS). Credentials may sit in the URL or in `REDIS_PASSWORD`.\n * - **HA (Sentinel)** — `REDIS_SENTINELS` (comma-separated `host:port`) plus\n *   `REDIS_SENTINEL_MASTER` (default `mymaster`) and optional\n *   `REDIS_SENTINEL_PASSWORD`. `REDIS_PASSWORD` authenticates to the data nodes.\n *   ioredis follows the master across a failover.\n *\n * Neither set → Redis is off, and each caller degrades to its documented\n * no-Redis behavior.\n *\n * `REDIS_HOST` / `REDIS_PORT` are not read. `REDIS_HOST` is refused outright so a\n * stale config fails at startup instead of silently running without Redis.\n * `REDIS_PORT` can't be refused: Kubernetes injects `REDIS_PORT=tcp://<ip>:6379`\n * into every pod in a namespace with a Service named `redis`, which is exactly\n * why a host/port pair was unsafe to parse.\n *\n * Misconfiguration throws {@link RedisConfigError}. Writers and readers of the\n * same keys (revocation, step-up, leader locks) must resolve Redis identically;\n * a config that quietly resolved to \"no Redis\" on one side is how revocation\n * once did nothing at all.\n */\n\n/** Thrown for a Redis environment that can't be used as written. */\nexport class RedisConfigError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'RedisConfigError';\n  }\n}\n\n/** Resolved connection, independent of any client library. */\nexport type RedisConnection =\n  | {\n    mode: 'sentinel';\n    sentinels: Array<{ host: string; port: number }>;\n    masterName: string;\n    password?: string;\n    sentinelPassword?: string;\n  }\n  | {\n    mode: 'url';\n    url: string;\n    password?: string;\n  };\n\n/**\n * Parse `REDIS_SENTINELS` into `{ host, port }[]`. Blank entries are skipped and\n * a missing port means the Sentinel default 26379; a port that isn't a valid\n * TCP port is a configuration error.\n */\nexport function parseSentinels(raw: string | undefined): Array<{ host: string; port: number }> {\n  if (!raw) return [];\n  return raw.split(',').map((s) => s.trim()).filter(Boolean).map((entry) => {\n    const idx = entry.lastIndexOf(':');\n    const host = idx === -1 ? entry : entry.slice(0, idx);\n    const portText = idx === -1 ? '' : entry.slice(idx + 1);\n    const port = portText === '' ? 26379 : Number(portText);\n    if (!host || !Number.isInteger(port) || port < 1 || port > 65535) {\n      throw new RedisConfigError(`REDIS_SENTINELS entry \"${entry}\" is not host:port`);\n    }\n    return { host, port };\n  });\n}\n\n/**\n * Resolve the Redis connection from `env`, or `null` when Redis isn't\n * configured. Throws {@link RedisConfigError} for an unusable configuration.\n */\nexport function resolveRedisConnection(env: NodeJS.ProcessEnv = process.env): RedisConnection | null {\n  if (env.REDIS_HOST) {\n    throw new RedisConfigError(\n      'REDIS_HOST is not supported. Set REDIS_URL=redis://<host>:<port> (or REDIS_SENTINELS for HA) and remove REDIS_HOST/REDIS_PORT.',\n    );\n  }\n\n  const sentinels = parseSentinels(env.REDIS_SENTINELS);\n  const url = env.REDIS_URL?.trim();\n  const password = env.REDIS_PASSWORD || undefined;\n\n  if (sentinels.length > 0 && url) {\n    throw new RedisConfigError('Set REDIS_URL or REDIS_SENTINELS, not both.');\n  }\n\n  if (sentinels.length > 0) {\n    return {\n      mode: 'sentinel',\n      sentinels,\n      masterName: env.REDIS_SENTINEL_MASTER || 'mymaster',\n      password,\n      sentinelPassword: env.REDIS_SENTINEL_PASSWORD || undefined,\n    };\n  }\n\n  if (url) {\n    let parsed: URL;\n    try {\n      parsed = new URL(url);\n    } catch {\n      throw new RedisConfigError('REDIS_URL is not a valid URL (expected redis://<host>:<port>).');\n    }\n    if (parsed.protocol !== 'redis:' && parsed.protocol !== 'rediss:') {\n      throw new RedisConfigError(`REDIS_URL must use redis:// or rediss://, got ${parsed.protocol}//`);\n    }\n    if (!parsed.hostname) throw new RedisConfigError('REDIS_URL has no host.');\n    return { mode: 'url', url, password };\n  }\n\n  return null;\n}\n\n/** A log-safe description of a connection (never includes credentials). */\nexport function describeRedisConnection(conn: RedisConnection): Record<string, unknown> {\n  if (conn.mode === 'sentinel') {\n    return { mode: 'sentinel', master: conn.masterName, sentinels: conn.sentinels.length };\n  }\n  const u = new URL(conn.url);\n  return { mode: 'url', host: u.hostname, port: u.port || '6379', tls: u.protocol === 'rediss:' };\n}\n\ntype RedisCtor<T> = new (...args: unknown[]) => T;\n\nfunction loadIoredis<T>(): RedisCtor<T> {\n  const req = createRequire(import.meta.url);\n  const mod = req('ioredis') as { Redis?: RedisCtor<T>; default?: RedisCtor<T> };\n  return (mod.Redis ?? mod.default ?? mod) as RedisCtor<T>;\n}\n\n/**\n * Construct an ioredis client for a resolved connection. `options` are merged\n * into the client options (e.g. `{ db, maxRetriesPerRequest: null }` for BullMQ).\n * An `error` listener is always attached so a dropped connection is logged\n * rather than surfacing as an unhandled `'error'` event that crashes Node.\n */\nexport function createRedisClient<T = unknown>(\n  conn: RedisConnection,\n  label: string,\n  options: Record<string, unknown> = {},\n): T {\n  const Ctor = loadIoredis<T>();\n  const auth = conn.password ? { password: conn.password } : {};\n  const inst = conn.mode === 'sentinel'\n    ? new Ctor({\n      sentinels: conn.sentinels,\n      name: conn.masterName,\n      ...(conn.sentinelPassword ? { sentinelPassword: conn.sentinelPassword } : {}),\n      ...auth,\n      ...options,\n    })\n    : new Ctor(conn.url, { ...auth, ...options });\n  (inst as unknown as { on: (evt: string, cb: (e: unknown) => void) => void })\n    .on('error', (e) => logger.warn(`Redis ${label} client error`, { error: e instanceof Error ? e.message : String(e) }));\n  return inst;\n}\n\n/**\n * The shared application Redis client: `null` when Redis isn't configured, so\n * the caller degrades to its no-Redis behavior.\n *\n * Commands fail fast (`maxRetriesPerRequest: 1`, no offline queue) because the\n * request-path callers are best-effort or fail closed on their own terms — a\n * request must not hang behind a Redis outage. That includes the moments before\n * the first connection completes: a background caller that runs at startup must\n * either tolerate a rejected command or wait with {@link whenRedisReady}.\n *\n * Throws {@link RedisConfigError} for a bad configuration, and if Redis is\n * configured but `ioredis` can't be loaded — both are deployment errors that\n * must not quietly turn Redis-backed guarantees off.\n */\nexport function createEnvRedisClient<T = unknown>(label: string): T | null {\n  const conn = resolveRedisConnection();\n  if (!conn) return null;\n  const inst = createRedisClient<T>(conn, label, { maxRetriesPerRequest: 1, enableOfflineQueue: false });\n  logger.info(`Redis ${label} client created`, describeRedisConnection(conn));\n  return inst;\n}\n\n/** The subset of ioredis needed to wait for a connection. */\nexport interface ReadyAwareRedis {\n  status?: string;\n  once?(event: string, cb: (...args: unknown[]) => void): unknown;\n  off?(event: string, cb: (...args: unknown[]) => void): unknown;\n}\n\n/**\n * Resolve once `client` is connected and ready for commands, or reject after\n * `timeoutMs`. For startup work (creating a consumer group, subscribing) that\n * otherwise races the first connection. A client without ioredis' `status`\n * (e.g. a test double) counts as ready.\n */\nexport function whenRedisReady(client: ReadyAwareRedis, timeoutMs = 30_000): Promise<void> {\n  if (client.status === undefined || client.status === 'ready' || !client.once) return Promise.resolve();\n  return new Promise((resolve, reject) => {\n    const onReady = () => { clearTimeout(timer); resolve(); };\n    const timer = setTimeout(() => {\n      client.off?.('ready', onReady);\n      reject(new Error(`Redis not ready after ${timeoutMs}ms`));\n    }, timeoutMs);\n    timer.unref?.();\n    client.once!('ready', onReady);\n  });\n}\n\n/** Default bound for {@link createRedisReadyGate}: short enough for a request path. */\nexport const REQUEST_PATH_REDIS_READY_TIMEOUT_MS = 2_000;\n\n/**\n * A request-path readiness gate for a lazily built env Redis client.\n *\n * The env client has no offline queue, so a command issued before the first\n * connection completes is rejected outright — the first request after a lazy\n * construction would otherwise hit that rejection (e.g. the first step-up per\n * pod failing, or the first impersonation check reading \"unavailable\").\n *\n * The returned function resolves once the client is ready, or after\n * `timeoutMs` — it NEVER rejects: the caller then runs its command and keeps its\n * own fail-open / fail-closed semantics. Concurrent callers share one wait. After\n * a wait times out (Redis genuinely down) later calls stop waiting until the\n * client reports `ready` again, so an outage costs one bounded wait instead of\n * adding `timeoutMs` to every request.\n */\nexport function createRedisReadyGate(\n  client: ReadyAwareRedis,\n  timeoutMs = REQUEST_PATH_REDIS_READY_TIMEOUT_MS,\n): () => Promise<void> {\n  let inflight: Promise<void> | null = null;\n  let gaveUp = false;\n  return () => {\n    if (client.status === undefined || client.status === 'ready' || !client.once) {\n      gaveUp = false;\n      return Promise.resolve();\n    }\n    if (gaveUp) return Promise.resolve();\n    if (!inflight) {\n      inflight = whenRedisReady(client, timeoutMs)\n        .catch(() => {\n          gaveUp = true;\n          // Re-arm the wait once the connection comes back.\n          client.once!('ready', () => { gaveUp = false; });\n        })\n        .finally(() => { inflight = null; });\n    }\n    return inflight;\n  };\n}\n\n/** The subset of ioredis needed by {@link incrWindow}. */\nexport interface RedisEvalClient {\n  eval(script: string, numKeys: number, ...args: (string | number)[]): Promise<unknown>;\n}\n\n/**\n * INCR a fixed-window counter and make sure it carries a TTL, atomically.\n *\n * A separate `INCR` then `EXPIRE` is not atomic: if the EXPIRE is lost (a\n * connection drop, a failover between the two commands) the key never expires\n * and the counter stays over its limit forever. The script also heals a key\n * that somehow lacks a TTL (`PTTL` = -1) rather than only setting it on the\n * first hit.\n */\nconst INCR_WINDOW_SCRIPT = `\nlocal n = redis.call('INCR', KEYS[1])\nif n == 1 or redis.call('PTTL', KEYS[1]) < 0 then\n  redis.call('PEXPIRE', KEYS[1], ARGV[1])\nend\nreturn n`;\n\n/**\n * Increment `key` within a window of `windowMs` and return the new count.\n * Throws when Redis errors — callers choose their own failure policy.\n */\nexport async function incrWindow(redis: RedisEvalClient, key: string, windowMs: number): Promise<number> {\n  const n = await redis.eval(INCR_WINDOW_SCRIPT, 1, key, Math.max(1, Math.ceil(windowMs)));\n  return Number(n);\n}\n"]}

package/lib/services/http-client.d.ts

@@ -55,32 +55,29 @@ export interface HttpClientResponse<T = unknown> {
  */
 export interface HttpClientOptions {
     /**
-     * A shared `http.Agent` to reuse across clients (pools sockets to the same
-     * host). When supplied, the client does NOT own it — {@link InternalHttpClient.destroy}
-     * leaves a borrowed agent untouched so other clients keep working.
+     * A caller-owned `http.Agent` to use instead of the process-wide shared one.
+     * The client never destroys it.
      */
     agent?: http.Agent;
-    /** Cap on concurrent keep-alive sockets when minting an agent (default 64). */
+    /** Cap on concurrent keep-alive sockets for the shared agent (default 64). */
     maxSockets?: number;
 }
+/**
+ * Close every shared keep-alive agent (idle sockets are released; in-flight
+ * requests finish). For process shutdown and tests — a later request simply
+ * builds a fresh agent.
+ */
+export declare function destroySharedHttpAgents(): void;
 export declare class InternalHttpClient {
     private config;
     private agent;
-    /** True only when this client MINTED its agent (so destroy() may tear it down). */
-    private readonly ownsAgent;
     /**
      * Create a new HTTP client instance.
      *
      * @param config - Service configuration
-     * @param options - Optional connection-pool controls (shared agent / socket cap)
+     * @param options - Optional connection-pool controls (own agent / socket cap)
      */
     constructor(config: ServiceConfig, options?: HttpClientOptions);
-    /**
-     * Release the keep-alive socket pool. Idempotent and safe to call on shutdown.
-     * A borrowed (caller-supplied) agent is left intact — only an agent this client
-     * created is destroyed, so tearing down one client can't sever another's pool.
-     */
-    destroy(): void;
     /**
      * Make a GET request.
      */
@@ -121,8 +118,6 @@ export declare class InternalHttpClient {
  * @returns Client wrapper with safe methods
  */
 export declare function createSafeClient(config: ServiceConfig, options?: HttpClientOptions): {
-    /** Release the underlying keep-alive socket pool (no-op on a borrowed agent). */
-    destroy(): void;
     /**
      * Safe GET request - returns null on error.
      */