@pipeline-builder/api-core 4.1.3 → 4.1.5

package/lib/services/env-redis.js

@@ -171,4 +171,66 @@ export function whenRedisReady(client, timeoutMs = 30_000) {
         client.once('ready', onReady);
     });
 }
-//# 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"]}
+/** 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.
+ *
+ * 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").
+ *
+ * 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 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();
+        }
+        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; });
+        }
+        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 * 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.
      */

package/lib/services/http-client.js

@@ -22,16 +22,42 @@ const DEFAULT_MAX_SOCKETS = parseInt(process.env.HTTP_CLIENT_MAX_SOCKETS || '64'
 // HTTP methods that are idempotent by definition — safe to auto-retry on a
 // 5xx/connection/timeout without risking a duplicate side effect.
 const IDEMPOTENT_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);
+/**
+ * Process-wide keep-alive agents, one per `host:port` (and socket cap) —
+ * mirroring the per-target circuit-breaker registry. Clients are cheap and often
+ * built per call (an org-hierarchy walk builds one per hop), so a per-client
+ * agent threw away its pooled sockets every time and the socket cap bounded
+ * nothing. Sharing the agent pools connections to a downstream across every
+ * client that targets it.
+ */
+const sharedAgents = new Map();
+function getSharedAgent(host, port, maxSockets) {
+    const key = `${host}:${port}:${maxSockets}`;
+    let agent = sharedAgents.get(key);
+    if (!agent) {
+        agent = new http.Agent({ keepAlive: true, maxSockets });
+        sharedAgents.set(key, agent);
+    }
+    return agent;
+}
+/**
+ * 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 function destroySharedHttpAgents() {
+    for (const agent of sharedAgents.values())
+        agent.destroy();
+    sharedAgents.clear();
+}
 export class InternalHttpClient {
     config;
     agent;
-    /** True only when this client MINTED its agent (so destroy() may tear it down). */
-    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, options) {
         this.config = {
@@ -39,25 +65,8 @@ export class InternalHttpClient {
             port: config.port,
             timeout: config.timeout ?? DEFAULT_TIMEOUT,
         };
-        if (options?.agent) {
-            // Borrowed, caller-owned agent — pooled across clients, not ours to destroy.
-            this.agent = options.agent;
-            this.ownsAgent = false;
-        }
-        else {
-            // Own a keep-alive agent with a BOUNDED socket pool (no more Infinity).
-            this.agent = new http.Agent({ keepAlive: true, maxSockets: options?.maxSockets ?? DEFAULT_MAX_SOCKETS });
-            this.ownsAgent = true;
-        }
-    }
-    /**
-     * 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() {
-        if (this.ownsAgent)
-            this.agent.destroy();
+        this.agent = options?.agent
+            ?? getSharedAgent(this.config.host, this.config.port, options?.maxSockets ?? DEFAULT_MAX_SOCKETS);
     }
     /**
      * Make a GET request.
@@ -277,10 +286,6 @@ export class InternalHttpClient {
 export function createSafeClient(config, options) {
     const client = new InternalHttpClient(config, options);
     return {
-        /** Release the underlying keep-alive socket pool (no-op on a borrowed agent). */
-        destroy() {
-            client.destroy();
-        },
         /**
          * Safe GET request - returns null on error.
          */
@@ -332,4 +337,4 @@ export function createSafeClient(config, options) {
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-client.js","sourceRoot":"","sources":["../../src/services/http-client.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as http from 'http';\nimport { getCircuitBreaker, CircuitOpenError } from './circuit-breaker.js';\nimport {\n  DEFAULT_MAX_RETRIES,\n  DEFAULT_RETRY_DELAY_MS,\n  DEFAULT_MAX_RATE_LIMIT_RETRIES,\n  getRetryDecision,\n  getErrorRetryDecision,\n  type RetryConfig,\n} from './retry-strategy.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport type { ServiceConfig } from '../types/common.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('http-client');\n\n/**\n * Default request timeout in milliseconds (env: `HTTP_CLIENT_TIMEOUT`).\n */\nconst DEFAULT_TIMEOUT = parseInt(process.env.HTTP_CLIENT_TIMEOUT || '5000', 10);\n\n/**\n * Default cap on concurrent keep-alive sockets per client agent\n * (env: `HTTP_CLIENT_MAX_SOCKETS`). Node's default is `Infinity`, which lets a\n * burst of concurrent calls open unbounded sockets against a downstream service\n * (fd exhaustion + connection-storm on the callee). 64 is ample for\n * service-to-service fan-out while staying bounded.\n */\nconst DEFAULT_MAX_SOCKETS = parseInt(process.env.HTTP_CLIENT_MAX_SOCKETS || '64', 10);\n\n// HTTP methods that are idempotent by definition — safe to auto-retry on a\n// 5xx/connection/timeout without risking a duplicate side effect.\nconst IDEMPOTENT_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);\n\n/**\n * HTTP request options.\n */\nexport interface RequestOptions {\n  /** Request headers */\n  headers?: Record<string, string>;\n  /** Request timeout in milliseconds */\n  timeout?: number;\n  /** Maximum retry attempts for transient failures (default: 2) */\n  maxRetries?: number;\n  /** Base delay between retries in ms — doubles each attempt (default: 200) */\n  retryDelayMs?: number;\n  /** Maximum retry attempts specifically for 429 rate limiting (default: 4) */\n  maxRateLimitRetries?: number;\n  /** Optional request ID for distributed tracing (added as X-Request-Id header) */\n  requestId?: string;\n  /**\n   * Treat this request as safe to auto-retry on 5xx/connection/timeout even\n   * though the method is non-idempotent (e.g. the endpoint is idempotent by an\n   * Idempotency-Key, or the operation is naturally idempotent). Default false:\n   * non-idempotent methods are NOT retried on those failures, only on 429.\n   */\n  idempotent?: boolean;\n}\n\n/**\n * HTTP client response wrapper.\n */\nexport interface HttpClientResponse<T = unknown> {\n  /** HTTP status code */\n  statusCode: number;\n  /** Response body (parsed JSON) */\n  body: T;\n  /** Response headers */\n  headers: http.IncomingHttpHeaders;\n}\n\n/**\n * Internal HTTP client for service-to-service communication.\n *\n * @example\n * ```typescript\n * const client = new InternalHttpClient({\n *   host: 'quota',\n *   port: 3000,\n *   timeout: 5000,\n * });\n *\n * const response = await client.get('/org123/apiCalls');\n * const result = await client.post('/org123/increment', { quotaType: 'apiCalls' });\n * ```\n */\n/**\n * Options controlling the client's connection pool.\n */\nexport interface HttpClientOptions {\n  /**\n   * A shared `http.Agent` to reuse across clients (pools sockets to the same\n   * host). When supplied, the client does NOT own it — {@link InternalHttpClient.destroy}\n   * leaves a borrowed agent untouched so other clients keep working.\n   */\n  agent?: http.Agent;\n  /** Cap on concurrent keep-alive sockets when minting an agent (default 64). */\n  maxSockets?: number;\n}\n\nexport class InternalHttpClient {\n  private config: Required<ServiceConfig>;\n  private agent: http.Agent;\n  /** True only when this client MINTED its agent (so destroy() may tear it down). */\n  private readonly ownsAgent: boolean;\n\n  /**\n   * Create a new HTTP client instance.\n   *\n   * @param config - Service configuration\n   * @param options - Optional connection-pool controls (shared agent / socket cap)\n   */\n  constructor(config: ServiceConfig, options?: HttpClientOptions) {\n    this.config = {\n      host: config.host,\n      port: config.port,\n      timeout: config.timeout ?? DEFAULT_TIMEOUT,\n    };\n    if (options?.agent) {\n      // Borrowed, caller-owned agent — pooled across clients, not ours to destroy.\n      this.agent = options.agent;\n      this.ownsAgent = false;\n    } else {\n      // Own a keep-alive agent with a BOUNDED socket pool (no more Infinity).\n      this.agent = new http.Agent({ keepAlive: true, maxSockets: options?.maxSockets ?? DEFAULT_MAX_SOCKETS });\n      this.ownsAgent = true;\n    }\n  }\n\n  /**\n   * Release the keep-alive socket pool. Idempotent and safe to call on shutdown.\n   * A borrowed (caller-supplied) agent is left intact — only an agent this client\n   * created is destroyed, so tearing down one client can't sever another's pool.\n   */\n  destroy(): void {\n    if (this.ownsAgent) this.agent.destroy();\n  }\n\n  /**\n   * Make a GET request.\n   */\n  async get<T = unknown>(path: string, options?: RequestOptions): Promise<HttpClientResponse<T>> {\n    return this.requestWithRetry<T>('GET', path, undefined, options);\n  }\n\n  /**\n   * Make a POST request.\n   */\n  async post<T = unknown>(\n    path: string,\n    body?: unknown,\n    options?: RequestOptions,\n  ): Promise<HttpClientResponse<T>> {\n    return this.requestWithRetry<T>('POST', path, body, options);\n  }\n\n  /**\n   * Make a PUT request.\n   */\n  async put<T = unknown>(\n    path: string,\n    body?: unknown,\n    options?: RequestOptions,\n  ): Promise<HttpClientResponse<T>> {\n    return this.requestWithRetry<T>('PUT', path, body, options);\n  }\n\n  /**\n   * Make a DELETE request.\n   */\n  async delete<T = unknown>(path: string, options?: RequestOptions): Promise<HttpClientResponse<T>> {\n    return this.requestWithRetry<T>('DELETE', path, undefined, options);\n  }\n\n  /**\n   * Request with retry logic for transient failures.\n   *\n   * - 429 (rate limit): respects `Retry-After` header, uses longer base delay (4x),\n   *   retries up to `maxRateLimitRetries` times (default 4).\n   * - 502/503/504 (server errors): standard exponential backoff, up to `maxRetries` (default 2).\n   * - Connection errors / timeouts: retries up to `maxRetries`.\n   * - All delays include ±25% jitter to prevent thundering herd.\n   */\n  private async requestWithRetry<T>(\n    method: string,\n    path: string,\n    body?: unknown,\n    options?: RequestOptions,\n  ): Promise<HttpClientResponse<T>> {\n    // A malformed path is a CLIENT bug, not a downstream fault — reject it up\n    // front so it never burns retries or feeds the circuit breaker (which would\n    // otherwise shed traffic to a perfectly healthy downstream). request() keeps\n    // the same guard as defence-in-depth.\n    if (path.includes('://') || path.startsWith('//') || /[\\r\\n\\0]/.test(path)) {\n      throw new Error(`Invalid request path: ${path}`);\n    }\n\n    const retryConfig: RetryConfig = {\n      maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES,\n      maxRateLimitRetries: options?.maxRateLimitRetries ?? DEFAULT_MAX_RATE_LIMIT_RETRIES,\n      retryDelayMs: options?.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS,\n    };\n    const totalMaxAttempts = Math.max(retryConfig.maxRetries, retryConfig.maxRateLimitRetries);\n\n    // Whether it's safe to auto-retry this request on a 5xx/connection/timeout.\n    // A timed-out POST may have already been processed server-side, so retrying\n    // a non-idempotent request risks a DUPLICATE side effect (double-charge,\n    // double-create). Only GET/HEAD/OPTIONS, an explicit `idempotent` opt-in, or\n    // a request carrying an Idempotency-Key are auto-retried on those failures.\n    // (429 is always retried — see below — since it was rejected, not processed.)\n    const retrySafe =\n      IDEMPOTENT_METHODS.has(method.toUpperCase()) ||\n      options?.idempotent === true ||\n      !!(options?.headers && (options.headers['Idempotency-Key'] || options.headers['idempotency-key']));\n\n    // Per-target circuit breaker + S2S request metrics. `target` is the shared\n    // breaker/metric key so one bad downstream trips once (not once-per-client)\n    // and dashboards can see S2S health per callee.\n    const target = `${this.config.host}:${this.config.port}`;\n    const breaker = getCircuitBreaker(target);\n    if (!breaker.allowRequest()) {\n      // Fast-fail without touching the network — this is the load-shedding that\n      // prevents a downstream brownout from cascading via retry storms.\n      emitCounter('s2s_requests_total', { target, method, outcome: 'circuit_open' });\n      throw new CircuitOpenError(target);\n    }\n\n    let lastError: Error | undefined;\n\n    for (let attempt = 0; attempt <= totalMaxAttempts; attempt++) {\n      try {\n        const response = await this.request<T>(method, path, body, options);\n\n        const decision = getRetryDecision(response.statusCode, response.headers, attempt, retryConfig);\n        // 429 is safe to retry for ANY method (rate-limited → not processed); a\n        // 5xx/gateway error is only retried when the request is retry-safe.\n        if (decision.shouldRetry && (response.statusCode === 429 || retrySafe)) {\n          logger.debug(decision.reason + ', retrying', { method, path, attempt: attempt + 1, delayMs: decision.delayMs });\n          emitCounter('s2s_request_retries_total', { target, method });\n          await this.sleep(decision.delayMs);\n          continue;\n        }\n\n        // Terminal response. A 5xx is a downstream fault (feeds the breaker); a\n        // 429 is backpressure, not a fault — the service answered, so it counts\n        // as success for breaker purposes (never trip the breaker on rate limits).\n        const isServerFault = response.statusCode >= 500 && response.statusCode <= 599;\n        if (isServerFault) {\n          breaker.recordFailure();\n          emitCounter('s2s_requests_total', { target, method, outcome: 'server_error' });\n        } else {\n          breaker.recordSuccess();\n          emitCounter('s2s_requests_total', { target, method, outcome: 'success' });\n        }\n        return response;\n      } catch (error) {\n        lastError = error instanceof Error ? error : new Error(String(error));\n\n        const decision = getErrorRetryDecision(attempt, retryConfig);\n        if (decision.shouldRetry && retrySafe) {\n          logger.debug('Retrying after error', { method, path, error: lastError.message, attempt: attempt + 1 });\n          emitCounter('s2s_request_retries_total', { target, method });\n          await this.sleep(decision.delayMs);\n          continue;\n        }\n        // Not retrying (non-idempotent, or attempts exhausted) — a connection\n        // error/timeout is a downstream fault: feed the breaker and fail now.\n        breaker.recordFailure();\n        emitCounter('s2s_requests_total', { target, method, outcome: 'error' });\n        throw lastError;\n      }\n    }\n\n    // Loop exhausted without returning (all attempts retried then ran out).\n    breaker.recordFailure();\n    emitCounter('s2s_requests_total', { target, method, outcome: 'error' });\n    throw lastError!;\n  }\n\n  private sleep(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n  }\n\n  /**\n   * Internal request method.\n   */\n  private request<T>(\n    method: string,\n    path: string,\n    body?: unknown,\n    options?: RequestOptions,\n  ): Promise<HttpClientResponse<T>> {\n    return new Promise((resolve, reject) => {\n      // Serialize when body is defined (including 0/false/'' which are valid JSON values).\n      const bodyStr = body !== undefined ? JSON.stringify(body) : undefined;\n\n      const headers: http.OutgoingHttpHeaders = {\n        'Content-Type': 'application/json',\n        ...options?.headers,\n      };\n\n      // Propagate request ID for distributed tracing\n      if (options?.requestId) {\n        headers['X-Request-Id'] = options.requestId;\n      }\n\n      if (bodyStr) {\n        headers['Content-Length'] = Buffer.byteLength(bodyStr);\n      }\n\n      // Validate path to prevent protocol injection / request smuggling\n      if (path.includes('://') || path.startsWith('//') || /[\\r\\n\\0]/.test(path)) {\n        throw new Error(`Invalid request path: ${path}`);\n      }\n\n      const requestOptions: http.RequestOptions = {\n        hostname: this.config.host,\n        port: this.config.port,\n        path: path.startsWith('/') ? path : `/${path}`,\n        method,\n        headers,\n        timeout: options?.timeout ?? this.config.timeout,\n        agent: this.agent,\n      };\n\n      const req = http.request(requestOptions, (res) => {\n        let data = '';\n\n        res.on('data', (chunk) => {\n          data += chunk;\n        });\n\n        res.on('end', () => {\n          try {\n            const parsedBody = data ? JSON.parse(data) : {};\n            resolve({\n              statusCode: res.statusCode || HttpStatus.INTERNAL_SERVER_ERROR,\n              body: parsedBody as T,\n              headers: res.headers,\n            });\n          } catch (parseError) {\n            logger.warn('Failed to parse response body', {\n              host: this.config.host,\n              path,\n              error: parseError instanceof Error ? parseError.message : String(parseError),\n            });\n            resolve({\n              statusCode: res.statusCode || HttpStatus.INTERNAL_SERVER_ERROR,\n              body: {} as T,\n              headers: res.headers,\n            });\n          }\n        });\n      });\n\n      req.on('error', (error) => {\n        // Node dual-stack connect failures are an AggregateError with an empty\n        // `.message`; the cause is in `.code` (ECONNREFUSED/ETIMEDOUT). Fall\n        // back so the log isn't a blank `error:\"\"`.\n        const detail = error.message || (error as NodeJS.ErrnoException).code || error.name;\n        logger.error('HTTP request failed', {\n          host: this.config.host,\n          port: this.config.port,\n          path,\n          method,\n          error: detail,\n        });\n        reject(error);\n      });\n\n      req.on('timeout', () => {\n        req.destroy();\n        const error = new Error(`Request timeout after ${this.config.timeout}ms`);\n        logger.warn('HTTP request timeout', {\n          host: this.config.host,\n          path,\n          timeout: this.config.timeout,\n        });\n        reject(error);\n      });\n\n      if (bodyStr) {\n        req.write(bodyStr);\n      }\n\n      req.end();\n    });\n  }\n}\n\n/**\n * Create an HTTP client with error handling that returns null on failure.\n * Useful for fail-open scenarios.\n *\n * @param config - Service configuration\n * @returns Client wrapper with safe methods\n */\nexport function createSafeClient(config: ServiceConfig, options?: HttpClientOptions) {\n  const client = new InternalHttpClient(config, options);\n\n  return {\n    /** Release the underlying keep-alive socket pool (no-op on a borrowed agent). */\n    destroy(): void {\n      client.destroy();\n    },\n\n    /**\n     * Safe GET request - returns null on error.\n     */\n    async get<T>(path: string, options?: RequestOptions): Promise<HttpClientResponse<T> | null> {\n      try {\n        return await client.get<T>(path, options);\n      } catch (err) {\n        logger.debug('Safe GET failed, returning null', { path, error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n\n    /**\n     * Safe POST request - returns null on error.\n     */\n    async post<T>(\n      path: string,\n      body?: unknown,\n      options?: RequestOptions,\n    ): Promise<HttpClientResponse<T> | null> {\n      try {\n        return await client.post<T>(path, body, options);\n      } catch (err) {\n        logger.debug('Safe POST failed, returning null', { path, error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n\n    /**\n     * Safe PUT request - returns null on error.\n     */\n    async put<T>(\n      path: string,\n      body?: unknown,\n      options?: RequestOptions,\n    ): Promise<HttpClientResponse<T> | null> {\n      try {\n        return await client.put<T>(path, body, options);\n      } catch (err) {\n        logger.debug('Safe PUT failed, returning null', { path, error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n\n    /**\n     * Safe DELETE request - returns null on error. Used by destructive\n     * cross-service operations (e.g. org-cascade delete in platform).\n     */\n    async delete<T>(\n      path: string,\n      options?: RequestOptions,\n    ): Promise<HttpClientResponse<T> | null> {\n      try {\n        return await client.delete<T>(path, options);\n      } catch (err) {\n        logger.debug('Safe DELETE failed, returning null', { path, error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-client.js","sourceRoot":"","sources":["../../src/services/http-client.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as http from 'http';\nimport { getCircuitBreaker, CircuitOpenError } from './circuit-breaker.js';\nimport {\n  DEFAULT_MAX_RETRIES,\n  DEFAULT_RETRY_DELAY_MS,\n  DEFAULT_MAX_RATE_LIMIT_RETRIES,\n  getRetryDecision,\n  getErrorRetryDecision,\n  type RetryConfig,\n} from './retry-strategy.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport type { ServiceConfig } from '../types/common.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('http-client');\n\n/**\n * Default request timeout in milliseconds (env: `HTTP_CLIENT_TIMEOUT`).\n */\nconst DEFAULT_TIMEOUT = parseInt(process.env.HTTP_CLIENT_TIMEOUT || '5000', 10);\n\n/**\n * Default cap on concurrent keep-alive sockets per client agent\n * (env: `HTTP_CLIENT_MAX_SOCKETS`). Node's default is `Infinity`, which lets a\n * burst of concurrent calls open unbounded sockets against a downstream service\n * (fd exhaustion + connection-storm on the callee). 64 is ample for\n * service-to-service fan-out while staying bounded.\n */\nconst DEFAULT_MAX_SOCKETS = parseInt(process.env.HTTP_CLIENT_MAX_SOCKETS || '64', 10);\n\n// HTTP methods that are idempotent by definition — safe to auto-retry on a\n// 5xx/connection/timeout without risking a duplicate side effect.\nconst IDEMPOTENT_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);\n\n/**\n * HTTP request options.\n */\nexport interface RequestOptions {\n  /** Request headers */\n  headers?: Record<string, string>;\n  /** Request timeout in milliseconds */\n  timeout?: number;\n  /** Maximum retry attempts for transient failures (default: 2) */\n  maxRetries?: number;\n  /** Base delay between retries in ms — doubles each attempt (default: 200) */\n  retryDelayMs?: number;\n  /** Maximum retry attempts specifically for 429 rate limiting (default: 4) */\n  maxRateLimitRetries?: number;\n  /** Optional request ID for distributed tracing (added as X-Request-Id header) */\n  requestId?: string;\n  /**\n   * Treat this request as safe to auto-retry on 5xx/connection/timeout even\n   * though the method is non-idempotent (e.g. the endpoint is idempotent by an\n   * Idempotency-Key, or the operation is naturally idempotent). Default false:\n   * non-idempotent methods are NOT retried on those failures, only on 429.\n   */\n  idempotent?: boolean;\n}\n\n/**\n * HTTP client response wrapper.\n */\nexport interface HttpClientResponse<T = unknown> {\n  /** HTTP status code */\n  statusCode: number;\n  /** Response body (parsed JSON) */\n  body: T;\n  /** Response headers */\n  headers: http.IncomingHttpHeaders;\n}\n\n/**\n * Internal HTTP client for service-to-service communication.\n *\n * @example\n * ```typescript\n * const client = new InternalHttpClient({\n *   host: 'quota',\n *   port: 3000,\n *   timeout: 5000,\n * });\n *\n * const response = await client.get('/org123/apiCalls');\n * const result = await client.post('/org123/increment', { quotaType: 'apiCalls' });\n * ```\n */\n/**\n * Options controlling the client's connection pool.\n */\nexport interface HttpClientOptions {\n  /**\n   * A caller-owned `http.Agent` to use instead of the process-wide shared one.\n   * The client never destroys it.\n   */\n  agent?: http.Agent;\n  /** Cap on concurrent keep-alive sockets for the shared agent (default 64). */\n  maxSockets?: number;\n}\n\n/**\n * Process-wide keep-alive agents, one per `host:port` (and socket cap) —\n * mirroring the per-target circuit-breaker registry. Clients are cheap and often\n * built per call (an org-hierarchy walk builds one per hop), so a per-client\n * agent threw away its pooled sockets every time and the socket cap bounded\n * nothing. Sharing the agent pools connections to a downstream across every\n * client that targets it.\n */\nconst sharedAgents = new Map<string, http.Agent>();\n\nfunction getSharedAgent(host: string, port: number, maxSockets: number): http.Agent {\n  const key = `${host}:${port}:${maxSockets}`;\n  let agent = sharedAgents.get(key);\n  if (!agent) {\n    agent = new http.Agent({ keepAlive: true, maxSockets });\n    sharedAgents.set(key, agent);\n  }\n  return agent;\n}\n\n/**\n * Close every shared keep-alive agent (idle sockets are released; in-flight\n * requests finish). For process shutdown and tests — a later request simply\n * builds a fresh agent.\n */\nexport function destroySharedHttpAgents(): void {\n  for (const agent of sharedAgents.values()) agent.destroy();\n  sharedAgents.clear();\n}\n\nexport class InternalHttpClient {\n  private config: Required<ServiceConfig>;\n  private agent: http.Agent;\n\n  /**\n   * Create a new HTTP client instance.\n   *\n   * @param config - Service configuration\n   * @param options - Optional connection-pool controls (own agent / socket cap)\n   */\n  constructor(config: ServiceConfig, options?: HttpClientOptions) {\n    this.config = {\n      host: config.host,\n      port: config.port,\n      timeout: config.timeout ?? DEFAULT_TIMEOUT,\n    };\n    this.agent = options?.agent\n      ?? getSharedAgent(this.config.host, this.config.port, options?.maxSockets ?? DEFAULT_MAX_SOCKETS);\n  }\n\n  /**\n   * Make a GET request.\n   */\n  async get<T = unknown>(path: string, options?: RequestOptions): Promise<HttpClientResponse<T>> {\n    return this.requestWithRetry<T>('GET', path, undefined, options);\n  }\n\n  /**\n   * Make a POST request.\n   */\n  async post<T = unknown>(\n    path: string,\n    body?: unknown,\n    options?: RequestOptions,\n  ): Promise<HttpClientResponse<T>> {\n    return this.requestWithRetry<T>('POST', path, body, options);\n  }\n\n  /**\n   * Make a PUT request.\n   */\n  async put<T = unknown>(\n    path: string,\n    body?: unknown,\n    options?: RequestOptions,\n  ): Promise<HttpClientResponse<T>> {\n    return this.requestWithRetry<T>('PUT', path, body, options);\n  }\n\n  /**\n   * Make a DELETE request.\n   */\n  async delete<T = unknown>(path: string, options?: RequestOptions): Promise<HttpClientResponse<T>> {\n    return this.requestWithRetry<T>('DELETE', path, undefined, options);\n  }\n\n  /**\n   * Request with retry logic for transient failures.\n   *\n   * - 429 (rate limit): respects `Retry-After` header, uses longer base delay (4x),\n   *   retries up to `maxRateLimitRetries` times (default 4).\n   * - 502/503/504 (server errors): standard exponential backoff, up to `maxRetries` (default 2).\n   * - Connection errors / timeouts: retries up to `maxRetries`.\n   * - All delays include ±25% jitter to prevent thundering herd.\n   */\n  private async requestWithRetry<T>(\n    method: string,\n    path: string,\n    body?: unknown,\n    options?: RequestOptions,\n  ): Promise<HttpClientResponse<T>> {\n    // A malformed path is a CLIENT bug, not a downstream fault — reject it up\n    // front so it never burns retries or feeds the circuit breaker (which would\n    // otherwise shed traffic to a perfectly healthy downstream). request() keeps\n    // the same guard as defence-in-depth.\n    if (path.includes('://') || path.startsWith('//') || /[\\r\\n\\0]/.test(path)) {\n      throw new Error(`Invalid request path: ${path}`);\n    }\n\n    const retryConfig: RetryConfig = {\n      maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES,\n      maxRateLimitRetries: options?.maxRateLimitRetries ?? DEFAULT_MAX_RATE_LIMIT_RETRIES,\n      retryDelayMs: options?.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS,\n    };\n    const totalMaxAttempts = Math.max(retryConfig.maxRetries, retryConfig.maxRateLimitRetries);\n\n    // Whether it's safe to auto-retry this request on a 5xx/connection/timeout.\n    // A timed-out POST may have already been processed server-side, so retrying\n    // a non-idempotent request risks a DUPLICATE side effect (double-charge,\n    // double-create). Only GET/HEAD/OPTIONS, an explicit `idempotent` opt-in, or\n    // a request carrying an Idempotency-Key are auto-retried on those failures.\n    // (429 is always retried — see below — since it was rejected, not processed.)\n    const retrySafe =\n      IDEMPOTENT_METHODS.has(method.toUpperCase()) ||\n      options?.idempotent === true ||\n      !!(options?.headers && (options.headers['Idempotency-Key'] || options.headers['idempotency-key']));\n\n    // Per-target circuit breaker + S2S request metrics. `target` is the shared\n    // breaker/metric key so one bad downstream trips once (not once-per-client)\n    // and dashboards can see S2S health per callee.\n    const target = `${this.config.host}:${this.config.port}`;\n    const breaker = getCircuitBreaker(target);\n    if (!breaker.allowRequest()) {\n      // Fast-fail without touching the network — this is the load-shedding that\n      // prevents a downstream brownout from cascading via retry storms.\n      emitCounter('s2s_requests_total', { target, method, outcome: 'circuit_open' });\n      throw new CircuitOpenError(target);\n    }\n\n    let lastError: Error | undefined;\n\n    for (let attempt = 0; attempt <= totalMaxAttempts; attempt++) {\n      try {\n        const response = await this.request<T>(method, path, body, options);\n\n        const decision = getRetryDecision(response.statusCode, response.headers, attempt, retryConfig);\n        // 429 is safe to retry for ANY method (rate-limited → not processed); a\n        // 5xx/gateway error is only retried when the request is retry-safe.\n        if (decision.shouldRetry && (response.statusCode === 429 || retrySafe)) {\n          logger.debug(decision.reason + ', retrying', { method, path, attempt: attempt + 1, delayMs: decision.delayMs });\n          emitCounter('s2s_request_retries_total', { target, method });\n          await this.sleep(decision.delayMs);\n          continue;\n        }\n\n        // Terminal response. A 5xx is a downstream fault (feeds the breaker); a\n        // 429 is backpressure, not a fault — the service answered, so it counts\n        // as success for breaker purposes (never trip the breaker on rate limits).\n        const isServerFault = response.statusCode >= 500 && response.statusCode <= 599;\n        if (isServerFault) {\n          breaker.recordFailure();\n          emitCounter('s2s_requests_total', { target, method, outcome: 'server_error' });\n        } else {\n          breaker.recordSuccess();\n          emitCounter('s2s_requests_total', { target, method, outcome: 'success' });\n        }\n        return response;\n      } catch (error) {\n        lastError = error instanceof Error ? error : new Error(String(error));\n\n        const decision = getErrorRetryDecision(attempt, retryConfig);\n        if (decision.shouldRetry && retrySafe) {\n          logger.debug('Retrying after error', { method, path, error: lastError.message, attempt: attempt + 1 });\n          emitCounter('s2s_request_retries_total', { target, method });\n          await this.sleep(decision.delayMs);\n          continue;\n        }\n        // Not retrying (non-idempotent, or attempts exhausted) — a connection\n        // error/timeout is a downstream fault: feed the breaker and fail now.\n        breaker.recordFailure();\n        emitCounter('s2s_requests_total', { target, method, outcome: 'error' });\n        throw lastError;\n      }\n    }\n\n    // Loop exhausted without returning (all attempts retried then ran out).\n    breaker.recordFailure();\n    emitCounter('s2s_requests_total', { target, method, outcome: 'error' });\n    throw lastError!;\n  }\n\n  private sleep(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n  }\n\n  /**\n   * Internal request method.\n   */\n  private request<T>(\n    method: string,\n    path: string,\n    body?: unknown,\n    options?: RequestOptions,\n  ): Promise<HttpClientResponse<T>> {\n    return new Promise((resolve, reject) => {\n      // Serialize when body is defined (including 0/false/'' which are valid JSON values).\n      const bodyStr = body !== undefined ? JSON.stringify(body) : undefined;\n\n      const headers: http.OutgoingHttpHeaders = {\n        'Content-Type': 'application/json',\n        ...options?.headers,\n      };\n\n      // Propagate request ID for distributed tracing\n      if (options?.requestId) {\n        headers['X-Request-Id'] = options.requestId;\n      }\n\n      if (bodyStr) {\n        headers['Content-Length'] = Buffer.byteLength(bodyStr);\n      }\n\n      // Validate path to prevent protocol injection / request smuggling\n      if (path.includes('://') || path.startsWith('//') || /[\\r\\n\\0]/.test(path)) {\n        throw new Error(`Invalid request path: ${path}`);\n      }\n\n      const requestOptions: http.RequestOptions = {\n        hostname: this.config.host,\n        port: this.config.port,\n        path: path.startsWith('/') ? path : `/${path}`,\n        method,\n        headers,\n        timeout: options?.timeout ?? this.config.timeout,\n        agent: this.agent,\n      };\n\n      const req = http.request(requestOptions, (res) => {\n        let data = '';\n\n        res.on('data', (chunk) => {\n          data += chunk;\n        });\n\n        res.on('end', () => {\n          try {\n            const parsedBody = data ? JSON.parse(data) : {};\n            resolve({\n              statusCode: res.statusCode || HttpStatus.INTERNAL_SERVER_ERROR,\n              body: parsedBody as T,\n              headers: res.headers,\n            });\n          } catch (parseError) {\n            logger.warn('Failed to parse response body', {\n              host: this.config.host,\n              path,\n              error: parseError instanceof Error ? parseError.message : String(parseError),\n            });\n            resolve({\n              statusCode: res.statusCode || HttpStatus.INTERNAL_SERVER_ERROR,\n              body: {} as T,\n              headers: res.headers,\n            });\n          }\n        });\n      });\n\n      req.on('error', (error) => {\n        // Node dual-stack connect failures are an AggregateError with an empty\n        // `.message`; the cause is in `.code` (ECONNREFUSED/ETIMEDOUT). Fall\n        // back so the log isn't a blank `error:\"\"`.\n        const detail = error.message || (error as NodeJS.ErrnoException).code || error.name;\n        logger.error('HTTP request failed', {\n          host: this.config.host,\n          port: this.config.port,\n          path,\n          method,\n          error: detail,\n        });\n        reject(error);\n      });\n\n      req.on('timeout', () => {\n        req.destroy();\n        const error = new Error(`Request timeout after ${this.config.timeout}ms`);\n        logger.warn('HTTP request timeout', {\n          host: this.config.host,\n          path,\n          timeout: this.config.timeout,\n        });\n        reject(error);\n      });\n\n      if (bodyStr) {\n        req.write(bodyStr);\n      }\n\n      req.end();\n    });\n  }\n}\n\n/**\n * Create an HTTP client with error handling that returns null on failure.\n * Useful for fail-open scenarios.\n *\n * @param config - Service configuration\n * @returns Client wrapper with safe methods\n */\nexport function createSafeClient(config: ServiceConfig, options?: HttpClientOptions) {\n  const client = new InternalHttpClient(config, options);\n\n  return {\n    /**\n     * Safe GET request - returns null on error.\n     */\n    async get<T>(path: string, options?: RequestOptions): Promise<HttpClientResponse<T> | null> {\n      try {\n        return await client.get<T>(path, options);\n      } catch (err) {\n        logger.debug('Safe GET failed, returning null', { path, error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n\n    /**\n     * Safe POST request - returns null on error.\n     */\n    async post<T>(\n      path: string,\n      body?: unknown,\n      options?: RequestOptions,\n    ): Promise<HttpClientResponse<T> | null> {\n      try {\n        return await client.post<T>(path, body, options);\n      } catch (err) {\n        logger.debug('Safe POST failed, returning null', { path, error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n\n    /**\n     * Safe PUT request - returns null on error.\n     */\n    async put<T>(\n      path: string,\n      body?: unknown,\n      options?: RequestOptions,\n    ): Promise<HttpClientResponse<T> | null> {\n      try {\n        return await client.put<T>(path, body, options);\n      } catch (err) {\n        logger.debug('Safe PUT failed, returning null', { path, error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n\n    /**\n     * Safe DELETE request - returns null on error. Used by destructive\n     * cross-service operations (e.g. org-cascade delete in platform).\n     */\n    async delete<T>(\n      path: string,\n      options?: RequestOptions,\n    ): Promise<HttpClientResponse<T> | null> {\n      try {\n        return await client.delete<T>(path, options);\n      } catch (err) {\n        logger.debug('Safe DELETE failed, returning null', { path, error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n  };\n}\n"]}

package/lib/services/index.d.ts

@@ -1,3 +1,4 @@
+export * from './api-key-exchange.js';
 export * from './cache-service.js';
 export * from './leader-lock.js';
 export * from './scheduler.js';
@@ -5,6 +6,8 @@ export * from './compliance-client.js';
 export * from './compliance-event-subscriber.js';
 export * from './entity-events.js';
 export * from './http-client.js';
+export * from './jwks-cache.js';
+export * from './service-keys.js';
 export * from './circuit-breaker.js';
 export * from './durable-event-bus.js';
 export { DEFAULT_MAX_RETRIES, DEFAULT_RETRY_DELAY_MS, DEFAULT_MAX_RATE_LIMIT_RETRIES, calculateBackoff, getRetryDecision, getErrorRetryDecision, } from './retry-strategy.js';

package/lib/services/index.js

@@ -1,5 +1,6 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+export * from './api-key-exchange.js';
 export * from './cache-service.js';
 export * from './leader-lock.js';
 export * from './scheduler.js';
@@ -7,6 +8,8 @@ export * from './compliance-client.js';
 export * from './compliance-event-subscriber.js';
 export * from './entity-events.js';
 export * from './http-client.js';
+export * from './jwks-cache.js';
+export * from './service-keys.js';
 export * from './circuit-breaker.js';
 export * from './durable-event-bus.js';
 export { DEFAULT_MAX_RETRIES, DEFAULT_RETRY_DELAY_MS, DEFAULT_MAX_RATE_LIMIT_RETRIES, calculateBackoff, getRetryDecision, getErrorRetryDecision, } from './retry-strategy.js';
@@ -17,4 +20,4 @@ export * from './env-redis.js';
 export * from './token-revocation.js';
 export * from './sse-ticket-store.js';
 export * from './service-boot.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/services/jwks-cache.d.ts

@@ -0,0 +1,102 @@
+/**
+ * The JWKS cache every verifier in the fleet shares.
+ *
+ * Platform signs user tokens with ES256 and publishes the public halves at
+ * `/.well-known/jwks.json`. Verifiers must not fetch that per request (platform
+ * would land on the hot path of the whole fleet) nor cache it forever (a rotated
+ * key would never be picked up), so the contract is fixed here and reused by
+ * api-core's `requireAuth`, image-registry's auth resolver and the CLI:
+ *
+ * - **Refresh every 10 minutes.** A key rotated in at platform is trusted fleet-
+ *   wide within that window without anyone restarting.
+ * - **Refetch once on an unknown `kid`.** A brand-new signing key is picked up
+ *   immediately instead of 401-ing every request until the next refresh. Rate-
+ *   limited ({@link UNKNOWN_KID_REFETCH_COOLDOWN_MS}) so a flood of forged `kid`s
+ *   can't turn into a fetch storm against platform.
+ * - **Negative-cache failures briefly.** A platform outage doesn't become a
+ *   fetch-per-request amplifier.
+ * - **Fail closed.** An unverifiable token is not an identity: when the key set
+ *   cannot be obtained the verifier throws {@link JwksUnavailableError} and the
+ *   caller answers 401/503 — it NEVER falls through to "allow".
+ *   A key set already in hand is still used while a refresh is failing (the keys
+ *   are public and don't expire; refusing every request because platform blipped
+ *   would be a self-inflicted outage), which is why the negative cache exists.
+ */
+import type { KeyObject } from 'crypto';
+import { type JwksDocument } from '../utils/jwk.js';
+/** How long a fetched key set is served before a refresh is due. */
+export declare const JWKS_REFRESH_INTERVAL_MS = 600000;
+/** How long a fetch FAILURE suppresses further attempts. */
+export declare const JWKS_NEGATIVE_TTL_MS = 10000;
+/** Minimum gap between unknown-`kid` refetches, so forged kids can't stampede platform. */
+export declare const UNKNOWN_KID_REFETCH_COOLDOWN_MS = 30000;
+/** The key set could not be obtained — the token's validity is UNKNOWN (503-shaped). */
+export declare class JwksUnavailableError extends Error {
+    constructor(message?: string);
+}
+/** The key set was obtained and does NOT contain the token's `kid` (401-shaped). */
+export declare class UnknownKidError extends Error {
+    constructor(kid: string);
+}
+/** Fetches the raw JWKS document. Rejects on any transport/shape failure. */
+export type JwksFetcher = () => Promise<JwksDocument>;
+export interface JwksCacheOptions {
+    fetch: JwksFetcher;
+    /** For metrics/logging (e.g. `'platform'`). */
+    source?: string;
+    refreshIntervalMs?: number;
+    negativeTtlMs?: number;
+    unknownKidCooldownMs?: number;
+}
+/**
+ * A key set with the freshness bookkeeping the contract above needs. Deliberately
+ * transport-agnostic: the CLI and the Lambda hand it their own fetcher.
+ */
+export declare class JwksCache {
+    private readonly options;
+    private keys;
+    private fetchedAt;
+    private failedUntil;
+    private lastUnknownKidFetchAt;
+    private inFlight;
+    private readonly refreshIntervalMs;
+    private readonly negativeTtlMs;
+    private readonly unknownKidCooldownMs;
+    private readonly source;
+    constructor(options: JwksCacheOptions);
+    /**
+     * The verification key for `kid`.
+     *
+     * @throws {JwksUnavailableError} the key set could not be obtained at all.
+     * @throws {UnknownKidError} the key set is in hand but has no such key.
+     */
+    getKey(kid: string): Promise<KeyObject>;
+    /** Every currently-trusted `kid`. Exposed for diagnostics and tests. */
+    knownKids(): string[];
+    /** Drop everything, so the next lookup refetches. */
+    reset(): void;
+    /** Refetch when the set is missing or past its refresh interval. */
+    private ensureFresh;
+    /** One real fetch, shared by every concurrent caller. */
+    private refresh;
+    private performFetch;
+}
+/**
+ * Fetch platform's JWKS over the in-cluster address every other caller uses
+ * (`PLATFORM_SERVICE_HOST` / `PLATFORM_SERVICE_PORT`), or the absolute
+ * `PLATFORM_JWKS_URL` when one is configured (the CLI and the events Lambda run
+ * outside the cluster).
+ *
+ * Unauthenticated by design: the key set is public, and requiring a credential
+ * to fetch the keys that verify credentials is a bootstrap cycle.
+ */
+export declare function fetchPlatformJwks(): Promise<JwksDocument>;
+/** Fetch a JWKS document from an absolute URL (outside-the-cluster verifiers). */
+export declare function fetchJwksFromUrl(url: string, timeoutMs?: number): Promise<JwksDocument>;
+/** The process-wide cache of platform's published signing keys. */
+export declare function platformJwksCache(): JwksCache;
+/**
+ * Replace the process-wide cache — used by tests, and by any host that must
+ * supply its own fetcher. Pass `undefined` to drop back to the default.
+ */
+export declare function setPlatformJwksCache(cache: JwksCache | undefined): void;