@pipeline-builder/api-core 4.1.7 → 4.1.9

package/lib/utils/ssrf.js

@@ -12,14 +12,21 @@
  * NAT / cloud-metadata range, so a tenant can't aim a webhook at
  * `169.254.169.254` or an in-cluster service.
  *
- * DNS-rebinding note: the up-front resolve validates the *initial* host only.
- * Node's global `fetch` (undici) re-resolves DNS for a redirect target
- * independently, so callers MUST send with `redirect: 'manual'` and treat any
- * 3xx as a failed delivery — see {@link SSRF_FETCH_INIT}. Pinning the exact
- * resolved IP for the connection would need a custom undici dispatcher (not a
- * dependency here); refusing redirects closes the practical rebinding pivot.
+ * TWO POSTURES, ONE SURVIVOR. `assertSafeUrl` only *validates* a URL: it
+ * resolves the host, checks the addresses and then throws the hostname away.
+ * Anything that goes on to `fetch(url)` re-resolves DNS and can therefore be
+ * pointed at a private address between the check and the connect (classic
+ * DNS rebinding). {@link safeFetch} is the posture that actually holds: it
+ * resolves, PINS the vetted IP into the socket's `lookup`, refuses redirects,
+ * and caps both the response size and the wall-clock time.
+ *
+ * So: use {@link safeFetch} for every outbound request to a user/tenant-supplied
+ * URL. `assertSafeUrl` is for NON-FETCH validation only — rejecting a bad URL at
+ * create/update time before it is ever stored. Never pair it with `fetch`.
  */
 import { lookup } from 'dns/promises';
+import { request as httpRequest } from 'http';
+import { request as httpsRequest } from 'https';
 import { isIP } from 'net';
 /**
  * True for loopback / private / link-local / CGNAT / cloud-metadata / ULA
@@ -61,12 +68,15 @@ export function isPrivateAddress(ip) {
         || addr.startsWith('fe80'); // link-local
 }
 /**
- * Reject a URL that is malformed, uses a disallowed protocol, or points at a
+ * Resolve and vet an outbound URL, returning the pinned target to connect to.
+ *
+ * Rejects a URL that is malformed, uses a disallowed protocol, or points at a
  * private/loopback/link-local/metadata address (by IP literal or by DNS
- * resolution). Throws a plain `Error` with a caller-safe message on rejection;
- * resolves silently when the URL is safe to fetch.
+ * resolution). Rejects if ANY resolution is private (defence in depth), then
+ * pins the first vetted address so the connection can never reach an address
+ * this function did not approve.
  */
-export async function assertSafeUrl(rawUrl, opts = {}) {
+export async function resolveSafeTarget(rawUrl, opts = {}) {
     const protocols = opts.protocols ?? ['https:'];
     let u;
     try {
@@ -78,9 +88,14 @@ export async function assertSafeUrl(rawUrl, opts = {}) {
     if (!protocols.includes(u.protocol)) {
         throw new Error(`url must use ${protocols.map((p) => p.replace(/:$/, '')).join('/')}`);
     }
-    const host = u.hostname;
-    if (isIP(host) && isPrivateAddress(host))
-        throw new Error('url targets a private address');
+    const host = u.hostname.replace(/^\[|\]$/g, '');
+    const port = u.port ? Number(u.port) : (u.protocol === 'http:' ? 80 : 443);
+    const literalFamily = isIP(host);
+    if (literalFamily) {
+        if (isPrivateAddress(host))
+            throw new Error('url targets a private address');
+        return { host, address: host, family: literalFamily, port, protocol: u.protocol };
+    }
     let addrs;
     try {
         addrs = await lookup(host, { all: true });
@@ -92,15 +107,117 @@ export async function assertSafeUrl(rawUrl, opts = {}) {
         throw new Error('url host did not resolve');
     if (addrs.some((a) => isPrivateAddress(a.address)))
         throw new Error('url resolves to a private address');
+    return { host, address: addrs[0].address, family: addrs[0].family, port, protocol: u.protocol };
+}
+/**
+ * VALIDATION ONLY — never pair this with a `fetch`.
+ *
+ * Resolves the host and throws when the URL is malformed, uses a disallowed
+ * protocol, or resolves to a private/loopback/link-local/metadata address. Use
+ * it to reject a bad URL at create/update time (before it is stored), or in any
+ * other place where nothing is about to connect. For an actual outbound request
+ * use {@link safeFetch}, which pins the address it vetted — validating here and
+ * then letting `fetch` re-resolve is a DNS-rebinding TOCTOU hole.
+ */
+export async function assertSafeUrl(rawUrl, opts = {}) {
+    await resolveSafeTarget(rawUrl, opts);
 }
+/** Default wall-clock cap for one {@link safeFetch} request. */
+export const SAFE_FETCH_TIMEOUT_MS = 10_000;
+/** Default response-body cap for {@link safeFetch} (5 MiB). */
+export const SAFE_FETCH_MAX_BYTES = 5 * 1024 * 1024;
 /**
- * `fetch` init fragment every SSRF-guarded call MUST spread so a redirect can't
- * pivot to an unvalidated (and re-resolved) host. Callers treat a 3xx / opaque
- * redirect response as a failed delivery rather than following it.
+ * SSRF-safe outbound request to a user/tenant-supplied URL.
+ *
+ * - resolves + vets the host, then PINS the exact validated IP into the socket
+ *   `lookup` so `net.connect` never re-resolves — this is what defeats DNS
+ *   rebinding. SNI + Host stay the original hostname so TLS verification is
+ *   unchanged.
+ * - REFUSES redirects: `http(s).request` never follows one, and a 3xx comes back
+ *   as `{ redirected: true, ok: false }` for the caller to record as a failure.
+ * - caps the response body ({@link SafeFetchOptions.maxResponseBytes}) and the
+ *   wall clock ({@link SafeFetchOptions.timeoutMs}).
+ *
+ * Throws on a rejected URL, a transport error, a timeout, or an oversized body.
  */
-export const SSRF_FETCH_INIT = { redirect: 'manual' };
-/** True when a `fetch` Response is (or was) a redirect the caller must refuse. */
-export function isRefusedRedirect(resp) {
-    return resp.type === 'opaqueredirect' || (resp.status >= 300 && resp.status < 400);
+export async function safeFetch(rawUrl, opts = {}) {
+    const maxBytes = opts.maxResponseBytes ?? SAFE_FETCH_MAX_BYTES;
+    const pin = await resolveSafeTarget(rawUrl, opts);
+    const u = new URL(rawUrl);
+    const body = opts.body === undefined
+        ? undefined
+        : (Buffer.isBuffer(opts.body) ? opts.body : Buffer.from(opts.body, 'utf8'));
+    // Compose the caller's abort with our own deadline so whichever fires first wins.
+    const timeout = AbortSignal.timeout(opts.timeoutMs ?? SAFE_FETCH_TIMEOUT_MS);
+    const signal = opts.signal ? AbortSignal.any([opts.signal, timeout]) : timeout;
+    const options = {
+        method: opts.method ?? 'GET',
+        hostname: pin.host,
+        port: pin.port,
+        path: `${u.pathname}${u.search}`,
+        servername: pin.protocol === 'https:' ? pin.host : undefined,
+        signal,
+        headers: {
+            ...opts.headers,
+            ...(body ? { 'Content-Length': String(body.byteLength) } : {}),
+        },
+        // Pin the vetted IP: net.connect uses this instead of re-resolving the host.
+        lookup: ((_hostname, _lookupOpts, cb) => {
+            cb(null, pin.address, pin.family);
+        }),
+    };
+    const send = pin.protocol === 'https:' ? httpsRequest : httpRequest;
+    return new Promise((resolve, reject) => {
+        const clientReq = send(options, (res) => {
+            const status = res.statusCode ?? 0;
+            const headers = {};
+            for (const [k, v] of Object.entries(res.headers)) {
+                if (v !== undefined)
+                    headers[k] = Array.isArray(v) ? v.join(', ') : String(v);
+            }
+            const redirected = status >= 300 && status < 400;
+            if (redirected) {
+                // Never follow, never buffer — drain so the socket can be released.
+                res.resume();
+                res.on('end', () => resolve(makeResponse(status, res.statusMessage, headers, Buffer.alloc(0), true)));
+                res.on('error', reject);
+                return;
+            }
+            // Early reject on a declared oversize before buffering anything.
+            const declared = Number(headers['content-length']);
+            if (Number.isFinite(declared) && declared > maxBytes) {
+                res.destroy();
+                reject(new Error(`Response body exceeds ${maxBytes} bytes`));
+                return;
+            }
+            const chunks = [];
+            let received = 0;
+            res.on('data', (chunk) => {
+                received += chunk.byteLength;
+                if (received > maxBytes) {
+                    res.destroy();
+                    reject(new Error(`Response body exceeds ${maxBytes} bytes`));
+                    return;
+                }
+                chunks.push(chunk);
+            });
+            res.on('end', () => resolve(makeResponse(status, res.statusMessage, headers, Buffer.concat(chunks), false)));
+            res.on('error', reject);
+        });
+        clientReq.on('error', reject);
+        clientReq.end(body);
+    });
+}
+function makeResponse(status, statusText, headers, body, redirected) {
+    return {
+        ok: status >= 200 && status < 300,
+        status,
+        statusText: statusText ?? '',
+        redirected,
+        headers,
+        body,
+        text: () => body.toString('utf8'),
+        json: () => JSON.parse(body.toString('utf8')),
+    };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ssrf.js","sourceRoot":"","sources":["../../src/utils/ssrf.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Shared SSRF guard for user/tenant-supplied outbound URLs (webhook targets,\n * callbacks, …). Promoted to api-core so every service that lets an org point\n * the platform at an arbitrary URL enforces the SAME denylist instead of each\n * re-deriving it (the compliance notifier and the platform alert relay both\n * consume this).\n *\n * The guard resolves the host up front and rejects any address that is — or\n * resolves to — a loopback / private / link-local / unique-local / carrier-grade\n * NAT / cloud-metadata range, so a tenant can't aim a webhook at\n * `169.254.169.254` or an in-cluster service.\n *\n * DNS-rebinding note: the up-front resolve validates the *initial* host only.\n * Node's global `fetch` (undici) re-resolves DNS for a redirect target\n * independently, so callers MUST send with `redirect: 'manual'` and treat any\n * 3xx as a failed delivery — see {@link SSRF_FETCH_INIT}. Pinning the exact\n * resolved IP for the connection would need a custom undici dispatcher (not a\n * dependency here); refusing redirects closes the practical rebinding pivot.\n */\n\nimport { lookup } from 'dns/promises';\nimport { isIP } from 'net';\n\n/**\n * True for loopback / private / link-local / CGNAT / cloud-metadata / ULA\n * addresses — the ranges an outbound tenant webhook must never reach.\n */\nexport function isPrivateAddress(ip: string): boolean {\n  const addr = ip.replace(/^\\[|\\]$/g, '').toLowerCase();\n  const v4 = addr.match(/^(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$/);\n  if (v4) {\n    const a = Number(v4[1]), b = Number(v4[2]);\n    return a === 0 || a === 10 || a === 127\n      || (a === 169 && b === 254) // link-local incl. 169.254.169.254 metadata\n      || (a === 172 && b >= 16 && b <= 31)\n      || (a === 192 && b === 168)\n      || (a === 100 && b >= 64 && b <= 127); // CGNAT\n  }\n  if (addr === '::1' || addr === '::') return true;\n  if (addr.startsWith('::ffff:')) {\n    const suffix = addr.slice(7);\n    // Dotted form (`::ffff:127.0.0.1`) — recurse straight into the v4 checks.\n    if (suffix.includes('.')) return isPrivateAddress(suffix);\n    // Hex form (`::ffff:7f00:1` = 127.0.0.1, `::ffff:c0a8:1` = 192.168.0.1):\n    // the low 32 bits are written as the last one/two hex groups. Fold them into\n    // a dotted quad and recurse so the v4 ranges below still catch it — without\n    // this the hex form slips past every check and reaches loopback/private space.\n    const groups = suffix.split(':');\n    const high = parseInt(groups[groups.length - 2] ?? '0', 16);\n    const low = parseInt(groups[groups.length - 1] ?? '0', 16);\n    if (Number.isNaN(high) || Number.isNaN(low)) return false;\n    // Fold each 16-bit half into two octets (arithmetic, not bitwise, to satisfy\n    // the no-bitwise lint): high → a.b, low → c.d.\n    const dotted = `${Math.floor(high / 256) % 256}.${high % 256}.${Math.floor(low / 256) % 256}.${low % 256}`;\n    return isPrivateAddress(dotted);\n  }\n  return addr.startsWith('fc') || addr.startsWith('fd') // unique-local\n    || addr.startsWith('fe80'); // link-local\n}\n\n/** Options for {@link assertSafeUrl}. */\nexport interface SafeUrlOptions {\n  /** Allowed URL protocols (default: `['https:']`). */\n  protocols?: string[];\n}\n\n/**\n * Reject a URL that is malformed, uses a disallowed protocol, or points at a\n * private/loopback/link-local/metadata address (by IP literal or by DNS\n * resolution). Throws a plain `Error` with a caller-safe message on rejection;\n * resolves silently when the URL is safe to fetch.\n */\nexport async function assertSafeUrl(rawUrl: string, opts: SafeUrlOptions = {}): Promise<void> {\n  const protocols = opts.protocols ?? ['https:'];\n  let u: URL;\n  try { u = new URL(rawUrl); } catch { throw new Error('invalid url'); }\n  if (!protocols.includes(u.protocol)) {\n    throw new Error(`url must use ${protocols.map((p) => p.replace(/:$/, '')).join('/')}`);\n  }\n  const host = u.hostname;\n  if (isIP(host) && isPrivateAddress(host)) throw new Error('url targets a private address');\n  let addrs: { address: string }[];\n  try { addrs = await lookup(host, { all: true }); } catch { throw new Error('url host did not resolve'); }\n  if (addrs.length === 0) throw new Error('url host did not resolve');\n  if (addrs.some((a) => isPrivateAddress(a.address))) throw new Error('url resolves to a private address');\n}\n\n/**\n * `fetch` init fragment every SSRF-guarded call MUST spread so a redirect can't\n * pivot to an unvalidated (and re-resolved) host. Callers treat a 3xx / opaque\n * redirect response as a failed delivery rather than following it.\n */\nexport const SSRF_FETCH_INIT = { redirect: 'manual' as const };\n\n/** True when a `fetch` Response is (or was) a redirect the caller must refuse. */\nexport function isRefusedRedirect(resp: { type?: string; status: number }): boolean {\n  return resp.type === 'opaqueredirect' || (resp.status >= 300 && resp.status < 400);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ssrf.js","sourceRoot":"","sources":["../../src/utils/ssrf.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Shared SSRF guard for user/tenant-supplied outbound URLs (webhook targets,\n * callbacks, …). Promoted to api-core so every service that lets an org point\n * the platform at an arbitrary URL enforces the SAME denylist instead of each\n * re-deriving it (the compliance notifier and the platform alert relay both\n * consume this).\n *\n * The guard resolves the host up front and rejects any address that is — or\n * resolves to — a loopback / private / link-local / unique-local / carrier-grade\n * NAT / cloud-metadata range, so a tenant can't aim a webhook at\n * `169.254.169.254` or an in-cluster service.\n *\n * TWO POSTURES, ONE SURVIVOR. `assertSafeUrl` only *validates* a URL: it\n * resolves the host, checks the addresses and then throws the hostname away.\n * Anything that goes on to `fetch(url)` re-resolves DNS and can therefore be\n * pointed at a private address between the check and the connect (classic\n * DNS rebinding). {@link safeFetch} is the posture that actually holds: it\n * resolves, PINS the vetted IP into the socket's `lookup`, refuses redirects,\n * and caps both the response size and the wall-clock time.\n *\n * So: use {@link safeFetch} for every outbound request to a user/tenant-supplied\n * URL. `assertSafeUrl` is for NON-FETCH validation only — rejecting a bad URL at\n * create/update time before it is ever stored. Never pair it with `fetch`.\n */\n\nimport { lookup } from 'dns/promises';\nimport { request as httpRequest } from 'http';\nimport { request as httpsRequest, type RequestOptions } from 'https';\nimport { isIP } from 'net';\n\n/**\n * True for loopback / private / link-local / CGNAT / cloud-metadata / ULA\n * addresses — the ranges an outbound tenant webhook must never reach.\n */\nexport function isPrivateAddress(ip: string): boolean {\n  const addr = ip.replace(/^\\[|\\]$/g, '').toLowerCase();\n  const v4 = addr.match(/^(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$/);\n  if (v4) {\n    const a = Number(v4[1]), b = Number(v4[2]);\n    return a === 0 || a === 10 || a === 127\n      || (a === 169 && b === 254) // link-local incl. 169.254.169.254 metadata\n      || (a === 172 && b >= 16 && b <= 31)\n      || (a === 192 && b === 168)\n      || (a === 100 && b >= 64 && b <= 127); // CGNAT\n  }\n  if (addr === '::1' || addr === '::') return true;\n  if (addr.startsWith('::ffff:')) {\n    const suffix = addr.slice(7);\n    // Dotted form (`::ffff:127.0.0.1`) — recurse straight into the v4 checks.\n    if (suffix.includes('.')) return isPrivateAddress(suffix);\n    // Hex form (`::ffff:7f00:1` = 127.0.0.1, `::ffff:c0a8:1` = 192.168.0.1):\n    // the low 32 bits are written as the last one/two hex groups. Fold them into\n    // a dotted quad and recurse so the v4 ranges below still catch it — without\n    // this the hex form slips past every check and reaches loopback/private space.\n    const groups = suffix.split(':');\n    const high = parseInt(groups[groups.length - 2] ?? '0', 16);\n    const low = parseInt(groups[groups.length - 1] ?? '0', 16);\n    if (Number.isNaN(high) || Number.isNaN(low)) return false;\n    // Fold each 16-bit half into two octets (arithmetic, not bitwise, to satisfy\n    // the no-bitwise lint): high → a.b, low → c.d.\n    const dotted = `${Math.floor(high / 256) % 256}.${high % 256}.${Math.floor(low / 256) % 256}.${low % 256}`;\n    return isPrivateAddress(dotted);\n  }\n  return addr.startsWith('fc') || addr.startsWith('fd') // unique-local\n    || addr.startsWith('fe80'); // link-local\n}\n\n/** Options for {@link assertSafeUrl}. */\nexport interface SafeUrlOptions {\n  /** Allowed URL protocols (default: `['https:']`). */\n  protocols?: string[];\n}\n\n/**\n * A DNS-resolved, SSRF-vetted target to connect to by PINNED IP.\n */\nexport interface PinnedTarget {\n  /** Original hostname — preserved for the Host header and TLS SNI. */\n  host: string;\n  /** The exact validated IP the socket must connect to (no re-resolution). */\n  address: string;\n  family: number;\n  port: number;\n  /** `'https:'` or `'http:'`. */\n  protocol: string;\n}\n\n/**\n * Resolve and vet an outbound URL, returning the pinned target to connect to.\n *\n * Rejects a URL that is malformed, uses a disallowed protocol, or points at a\n * private/loopback/link-local/metadata address (by IP literal or by DNS\n * resolution). Rejects if ANY resolution is private (defence in depth), then\n * pins the first vetted address so the connection can never reach an address\n * this function did not approve.\n */\nexport async function resolveSafeTarget(rawUrl: string, opts: SafeUrlOptions = {}): Promise<PinnedTarget> {\n  const protocols = opts.protocols ?? ['https:'];\n  let u: URL;\n  try { u = new URL(rawUrl); } catch { throw new Error('invalid url'); }\n  if (!protocols.includes(u.protocol)) {\n    throw new Error(`url must use ${protocols.map((p) => p.replace(/:$/, '')).join('/')}`);\n  }\n  const host = u.hostname.replace(/^\\[|\\]$/g, '');\n  const port = u.port ? Number(u.port) : (u.protocol === 'http:' ? 80 : 443);\n  const literalFamily = isIP(host);\n  if (literalFamily) {\n    if (isPrivateAddress(host)) throw new Error('url targets a private address');\n    return { host, address: host, family: literalFamily, port, protocol: u.protocol };\n  }\n  let addrs: { address: string; family: number }[];\n  try { addrs = await lookup(host, { all: true }); } catch { throw new Error('url host did not resolve'); }\n  if (addrs.length === 0) throw new Error('url host did not resolve');\n  if (addrs.some((a) => isPrivateAddress(a.address))) throw new Error('url resolves to a private address');\n  return { host, address: addrs[0].address, family: addrs[0].family, port, protocol: u.protocol };\n}\n\n/**\n * VALIDATION ONLY — never pair this with a `fetch`.\n *\n * Resolves the host and throws when the URL is malformed, uses a disallowed\n * protocol, or resolves to a private/loopback/link-local/metadata address. Use\n * it to reject a bad URL at create/update time (before it is stored), or in any\n * other place where nothing is about to connect. For an actual outbound request\n * use {@link safeFetch}, which pins the address it vetted — validating here and\n * then letting `fetch` re-resolve is a DNS-rebinding TOCTOU hole.\n */\nexport async function assertSafeUrl(rawUrl: string, opts: SafeUrlOptions = {}): Promise<void> {\n  await resolveSafeTarget(rawUrl, opts);\n}\n\n/** Default wall-clock cap for one {@link safeFetch} request. */\nexport const SAFE_FETCH_TIMEOUT_MS = 10_000;\n/** Default response-body cap for {@link safeFetch} (5 MiB). */\nexport const SAFE_FETCH_MAX_BYTES = 5 * 1024 * 1024;\n\n/** Options for {@link safeFetch}. */\nexport interface SafeFetchOptions extends SafeUrlOptions {\n  method?: string;\n  headers?: Record<string, string>;\n  body?: string | Buffer;\n  /** Caller abort (composed with `timeoutMs`). */\n  signal?: AbortSignal;\n  /** Wall-clock cap for the whole request (default {@link SAFE_FETCH_TIMEOUT_MS}). */\n  timeoutMs?: number;\n  /** Body-size cap; exceeding it aborts and throws (default {@link SAFE_FETCH_MAX_BYTES}). */\n  maxResponseBytes?: number;\n}\n\n/** Normalized response from {@link safeFetch}. */\nexport interface SafeFetchResponse {\n  /** True only for a 2xx. A refused redirect is never `ok`. */\n  ok: boolean;\n  status: number;\n  statusText: string;\n  /** True when the origin answered with a 3xx — REFUSED, never followed. */\n  redirected: boolean;\n  headers: Record<string, string>;\n  /** Raw body bytes (empty for a refused redirect, whose body is discarded). */\n  body: Buffer;\n  text(): string;\n  json<T = unknown>(): T;\n}\n\n/**\n * SSRF-safe outbound request to a user/tenant-supplied URL.\n *\n * - resolves + vets the host, then PINS the exact validated IP into the socket\n *   `lookup` so `net.connect` never re-resolves — this is what defeats DNS\n *   rebinding. SNI + Host stay the original hostname so TLS verification is\n *   unchanged.\n * - REFUSES redirects: `http(s).request` never follows one, and a 3xx comes back\n *   as `{ redirected: true, ok: false }` for the caller to record as a failure.\n * - caps the response body ({@link SafeFetchOptions.maxResponseBytes}) and the\n *   wall clock ({@link SafeFetchOptions.timeoutMs}).\n *\n * Throws on a rejected URL, a transport error, a timeout, or an oversized body.\n */\nexport async function safeFetch(rawUrl: string, opts: SafeFetchOptions = {}): Promise<SafeFetchResponse> {\n  const maxBytes = opts.maxResponseBytes ?? SAFE_FETCH_MAX_BYTES;\n  const pin = await resolveSafeTarget(rawUrl, opts);\n  const u = new URL(rawUrl);\n  const body = opts.body === undefined\n    ? undefined\n    : (Buffer.isBuffer(opts.body) ? opts.body : Buffer.from(opts.body, 'utf8'));\n\n  // Compose the caller's abort with our own deadline so whichever fires first wins.\n  const timeout = AbortSignal.timeout(opts.timeoutMs ?? SAFE_FETCH_TIMEOUT_MS);\n  const signal = opts.signal ? AbortSignal.any([opts.signal, timeout]) : timeout;\n\n  const options: RequestOptions = {\n    method: opts.method ?? 'GET',\n    hostname: pin.host,\n    port: pin.port,\n    path: `${u.pathname}${u.search}`,\n    servername: pin.protocol === 'https:' ? pin.host : undefined,\n    signal,\n    headers: {\n      ...opts.headers,\n      ...(body ? { 'Content-Length': String(body.byteLength) } : {}),\n    },\n    // Pin the vetted IP: net.connect uses this instead of re-resolving the host.\n    lookup: ((_hostname: string, _lookupOpts: unknown, cb: (err: Error | null, address: string, family: number) => void) => {\n      cb(null, pin.address, pin.family);\n    }) as unknown as RequestOptions['lookup'],\n  };\n\n  const send = pin.protocol === 'https:' ? httpsRequest : httpRequest;\n\n  return new Promise<SafeFetchResponse>((resolve, reject) => {\n    const clientReq = send(options, (res) => {\n      const status = res.statusCode ?? 0;\n      const headers: Record<string, string> = {};\n      for (const [k, v] of Object.entries(res.headers)) {\n        if (v !== undefined) headers[k] = Array.isArray(v) ? v.join(', ') : String(v);\n      }\n      const redirected = status >= 300 && status < 400;\n      if (redirected) {\n        // Never follow, never buffer — drain so the socket can be released.\n        res.resume();\n        res.on('end', () => resolve(makeResponse(status, res.statusMessage, headers, Buffer.alloc(0), true)));\n        res.on('error', reject);\n        return;\n      }\n      // Early reject on a declared oversize before buffering anything.\n      const declared = Number(headers['content-length']);\n      if (Number.isFinite(declared) && declared > maxBytes) {\n        res.destroy();\n        reject(new Error(`Response body exceeds ${maxBytes} bytes`));\n        return;\n      }\n      const chunks: Buffer[] = [];\n      let received = 0;\n      res.on('data', (chunk: Buffer) => {\n        received += chunk.byteLength;\n        if (received > maxBytes) {\n          res.destroy();\n          reject(new Error(`Response body exceeds ${maxBytes} bytes`));\n          return;\n        }\n        chunks.push(chunk);\n      });\n      res.on('end', () => resolve(makeResponse(status, res.statusMessage, headers, Buffer.concat(chunks), false)));\n      res.on('error', reject);\n    });\n    clientReq.on('error', reject);\n    clientReq.end(body);\n  });\n}\n\nfunction makeResponse(\n  status: number,\n  statusText: string | undefined,\n  headers: Record<string, string>,\n  body: Buffer,\n  redirected: boolean,\n): SafeFetchResponse {\n  return {\n    ok: status >= 200 && status < 300,\n    status,\n    statusText: statusText ?? '',\n    redirected,\n    headers,\n    body,\n    text: () => body.toString('utf8'),\n    json: <T>() => JSON.parse(body.toString('utf8')) as T,\n  };\n}\n"]}

package/package.json

@@ -91,10 +91,13 @@
     "*": {
       "permissions": [
         "lib/types/permissions.d.ts"
+      ],
+      "metadata-keys": [
+        "lib/types/metadata-keys.d.ts"
       ]
     }
   },
-  "version": "4.1.7",
+  "version": "4.1.9",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },
@@ -153,6 +156,24 @@
     "moduleNameMapper": {
       "^uuid$": "<rootDir>/../../jest-uuid-stub.js",
       "^(\\.{1,2}/.*)\\.js$": "$1"
+    },
+    "restoreMocks": true,
+    "setupFilesAfterEnv": [
+      "<rootDir>/../../jest-env-guard.js"
+    ],
+    "coverageThreshold": {
+      "global": {
+        "statements": 95,
+        "branches": 88,
+        "functions": 88,
+        "lines": 95
+      },
+      "**/src/utils/audit.ts": {
+        "statements": 95,
+        "branches": 95,
+        "functions": 95,
+        "lines": 95
+      }
     }
   },
   "types": "lib/index.d.ts",
@@ -166,6 +187,10 @@
       "types": "./lib/types/permissions.d.ts",
       "default": "./lib/types/permissions.js"
     },
+    "./metadata-keys": {
+      "types": "./lib/types/metadata-keys.d.ts",
+      "default": "./lib/types/metadata-keys.js"
+    },
     "./lib/*": "./lib/*",
     "./package.json": "./package.json"
   },