@pipeline-builder/api-core 4.1.3 → 4.1.4

package/lib/utils/jwk.js

@@ -0,0 +1,139 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * JWK primitives for the ASYMMETRIC user-token chain.
+ *
+ * Every token that speaks for a PERSON (access, refresh, step-up, and the
+ * short-lived token an opaque access key is exchanged for) is signed by
+ * **platform alone**, with ES256 and a `kid`, and verified by everyone else
+ * against the public keys platform publishes at `/.well-known/jwks.json`. No
+ * service holds a key that can mint a user token any more.
+ *
+ * Only Node's `crypto` is used — `createPublicKey`/`export` already speak JWK,
+ * so nothing here needs a JOSE library.
+ *
+ * Internal SERVICE tokens (`principalType: 'service'`) are ES256 too, signed by
+ * the CALLING service with its own key (#14, `services/service-keys.ts`). Both
+ * chains therefore share these primitives, and a bearer token is routed by which
+ * key set owns its `kid` rather than by its algorithm — see `middleware/auth.ts`.
+ */
+import crypto, {} from 'crypto';
+/** The ONLY algorithm a user token may be signed with. */
+export const USER_TOKEN_ALGORITHM = 'ES256';
+/** The curve ES256 pins (`ECDSA_NIST_P256` / `prime256v1` / `ECC_NIST_P256` in KMS terms). */
+export const USER_TOKEN_CURVE = 'P-256';
+/** Path the public key set is served from (platform mounts it; nginx proxies it). */
+export const JWKS_PATH = '/.well-known/jwks.json';
+/**
+ * Decode a JWT's header WITHOUT verifying anything. Returns `null` for anything
+ * that is not a three-part token with a JSON object header — the caller then
+ * rejects, so this never widens what is accepted.
+ */
+export function decodeJwtHeader(token) {
+    const parts = token.split('.');
+    if (parts.length !== 3 || !parts[0])
+        return null;
+    try {
+        const header = JSON.parse(Buffer.from(parts[0], 'base64url').toString('utf-8'));
+        if (!header || typeof header !== 'object' || Array.isArray(header))
+            return null;
+        return header;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The RFC 7638 thumbprint of an EC public key, base64url-encoded — used as the
+ * `kid` everywhere.
+ *
+ * Deriving the id FROM the key (rather than naming keys by hand, or by their KMS
+ * ARN) means the same key always publishes under the same `kid` whatever signer
+ * holds it, a rotated-in key can never collide with the one it replaces, and no
+ * AWS account id ever reaches a token or the public JWKS.
+ *
+ * The hashed form is the canonical JSON of exactly `crv`, `kty`, `x`, `y`, in
+ * lexicographic order and with no whitespace — the spec's required members for
+ * an EC key.
+ */
+export function jwkThumbprint(jwk) {
+    const canonical = JSON.stringify({ crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y });
+    return crypto.createHash('sha256').update(canonical).digest('base64url');
+}
+/**
+ * Project an EC P-256 public key onto the published JWK shape, with its
+ * thumbprint as `kid`. Throws when the key is not a P-256 EC key — a signer
+ * configured with the wrong key type must fail at boot, not mint tokens nobody
+ * can verify.
+ */
+export function publicJwkFrom(key) {
+    const exported = key.export({ format: 'jwk' });
+    if (exported.kty !== 'EC' || exported.crv !== USER_TOKEN_CURVE || !exported.x || !exported.y) {
+        throw new Error(`Token signing key must be an EC ${USER_TOKEN_CURVE} public key (got ${exported.kty ?? 'unknown'}/${exported.crv ?? 'unknown'})`);
+    }
+    const base = { kty: 'EC', crv: USER_TOKEN_CURVE, x: exported.x, y: exported.y };
+    return { ...base, kid: jwkThumbprint(base), use: 'sig', alg: 'ES256' };
+}
+/**
+ * Turn a published JWK back into a verification key. Throws for anything that is
+ * not an ES256-usable P-256 key, so a JWKS document with a surprise entry
+ * (a future RSA key, a `use: 'enc'` key) can never be pressed into verifying a
+ * user token.
+ */
+export function publicKeyFromJwk(jwk) {
+    if (jwk.kty !== 'EC' || jwk.crv !== USER_TOKEN_CURVE) {
+        throw new Error(`Unsupported JWKS entry: ${jwk.kty}/${jwk.crv}`);
+    }
+    if (jwk.use !== undefined && jwk.use !== 'sig')
+        throw new Error('JWKS entry is not a signing key');
+    if (jwk.alg !== undefined && jwk.alg !== USER_TOKEN_ALGORITHM)
+        throw new Error(`JWKS entry algorithm is not ${USER_TOKEN_ALGORITHM}`);
+    return crypto.createPublicKey({ key: { kty: 'EC', crv: jwk.crv, x: jwk.x, y: jwk.y }, format: 'jwk' });
+}
+/** True when `value` is shaped like the JWKS document (keys array of objects). */
+export function isJwksDocument(value) {
+    return !!value
+        && typeof value === 'object'
+        && Array.isArray(value.keys)
+        && value.keys.every((k) => !!k && typeof k === 'object');
+}
+/**
+ * Convert an ECDSA signature from ASN.1 DER (what AWS KMS returns) to the raw
+ * fixed-width `r || s` JOSE form a JWT carries.
+ *
+ * DER is `SEQUENCE { INTEGER r, INTEGER s }` with both integers minimally
+ * encoded and sign-padded; JOSE wants each coordinate left-zero-padded to
+ * exactly the curve size (32 bytes for P-256). Getting this wrong produces
+ * tokens that verify nowhere, so it is strict: any structural surprise throws.
+ */
+export function derToJoseSignature(der, coordinateBytes = 32) {
+    if (der[0] !== 0x30)
+        throw new Error('Malformed DER signature: expected SEQUENCE');
+    // Length byte(s): short form (<0x80) or long form (0x81 for a 1-byte length).
+    let offset = 1;
+    if (der[offset] === 0x81)
+        offset += 2;
+    else if (der[offset] < 0x80)
+        offset += 1;
+    else
+        throw new Error('Malformed DER signature: unsupported length encoding');
+    const readInt = () => {
+        if (der[offset] !== 0x02)
+            throw new Error('Malformed DER signature: expected INTEGER');
+        const len = der[offset + 1];
+        const start = offset + 2;
+        offset = start + len;
+        let value = der.subarray(start, offset);
+        // Strip the sign-padding byte DER adds when the high bit is set…
+        while (value.length > coordinateBytes && value[0] === 0x00)
+            value = value.subarray(1);
+        if (value.length > coordinateBytes)
+            throw new Error('Malformed DER signature: coordinate too large');
+        // …then left-pad back out to the fixed curve width JOSE requires.
+        return Buffer.concat([Buffer.alloc(coordinateBytes - value.length), value]);
+    };
+    const r = readInt();
+    const s = readInt();
+    return Buffer.concat([r, s]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jwk.js","sourceRoot":"","sources":["../../src/utils/jwk.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * JWK primitives for the ASYMMETRIC user-token chain.\n *\n * Every token that speaks for a PERSON (access, refresh, step-up, and the\n * short-lived token an opaque access key is exchanged for) is signed by\n * **platform alone**, with ES256 and a `kid`, and verified by everyone else\n * against the public keys platform publishes at `/.well-known/jwks.json`. No\n * service holds a key that can mint a user token any more.\n *\n * Only Node's `crypto` is used — `createPublicKey`/`export` already speak JWK,\n * so nothing here needs a JOSE library.\n *\n * Internal SERVICE tokens (`principalType: 'service'`) are ES256 too, signed by\n * the CALLING service with its own key (#14, `services/service-keys.ts`). Both\n * chains therefore share these primitives, and a bearer token is routed by which\n * key set owns its `kid` rather than by its algorithm — see `middleware/auth.ts`.\n */\n\nimport crypto, { type KeyObject } from 'crypto';\n\n/** The ONLY algorithm a user token may be signed with. */\nexport const USER_TOKEN_ALGORITHM = 'ES256';\n\n/** The curve ES256 pins (`ECDSA_NIST_P256` / `prime256v1` / `ECC_NIST_P256` in KMS terms). */\nexport const USER_TOKEN_CURVE = 'P-256';\n\n/** Path the public key set is served from (platform mounts it; nginx proxies it). */\nexport const JWKS_PATH = '/.well-known/jwks.json';\n\n/** One published EC public key. */\nexport interface PublicJwk {\n  kty: 'EC';\n  crv: 'P-256';\n  /** base64url X coordinate. */\n  x: string;\n  /** base64url Y coordinate. */\n  y: string;\n  /** RFC 7638 thumbprint — stable for the key, so rotation is a `kid` change. */\n  kid: string;\n  use: 'sig';\n  alg: 'ES256';\n}\n\n/** The document served at {@link JWKS_PATH}. */\nexport interface JwksDocument {\n  keys: PublicJwk[];\n}\n\n/** The header fields a verifier needs before it can pick a key. */\nexport interface JwtHeader {\n  alg?: string;\n  kid?: string;\n  typ?: string;\n}\n\n/**\n * Decode a JWT's header WITHOUT verifying anything. Returns `null` for anything\n * that is not a three-part token with a JSON object header — the caller then\n * rejects, so this never widens what is accepted.\n */\nexport function decodeJwtHeader(token: string): JwtHeader | null {\n  const parts = token.split('.');\n  if (parts.length !== 3 || !parts[0]) return null;\n  try {\n    const header = JSON.parse(Buffer.from(parts[0], 'base64url').toString('utf-8')) as unknown;\n    if (!header || typeof header !== 'object' || Array.isArray(header)) return null;\n    return header as JwtHeader;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * The RFC 7638 thumbprint of an EC public key, base64url-encoded — used as the\n * `kid` everywhere.\n *\n * Deriving the id FROM the key (rather than naming keys by hand, or by their KMS\n * ARN) means the same key always publishes under the same `kid` whatever signer\n * holds it, a rotated-in key can never collide with the one it replaces, and no\n * AWS account id ever reaches a token or the public JWKS.\n *\n * The hashed form is the canonical JSON of exactly `crv`, `kty`, `x`, `y`, in\n * lexicographic order and with no whitespace — the spec's required members for\n * an EC key.\n */\nexport function jwkThumbprint(jwk: { crv: string; kty: string; x: string; y: string }): string {\n  const canonical = JSON.stringify({ crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y });\n  return crypto.createHash('sha256').update(canonical).digest('base64url');\n}\n\n/**\n * Project an EC P-256 public key onto the published JWK shape, with its\n * thumbprint as `kid`. Throws when the key is not a P-256 EC key — a signer\n * configured with the wrong key type must fail at boot, not mint tokens nobody\n * can verify.\n */\nexport function publicJwkFrom(key: KeyObject): PublicJwk {\n  const exported = key.export({ format: 'jwk' }) as { kty?: string; crv?: string; x?: string; y?: string };\n  if (exported.kty !== 'EC' || exported.crv !== USER_TOKEN_CURVE || !exported.x || !exported.y) {\n    throw new Error(`Token signing key must be an EC ${USER_TOKEN_CURVE} public key (got ${exported.kty ?? 'unknown'}/${exported.crv ?? 'unknown'})`);\n  }\n  const base = { kty: 'EC' as const, crv: USER_TOKEN_CURVE as 'P-256', x: exported.x, y: exported.y };\n  return { ...base, kid: jwkThumbprint(base), use: 'sig', alg: 'ES256' };\n}\n\n/**\n * Turn a published JWK back into a verification key. Throws for anything that is\n * not an ES256-usable P-256 key, so a JWKS document with a surprise entry\n * (a future RSA key, a `use: 'enc'` key) can never be pressed into verifying a\n * user token.\n */\nexport function publicKeyFromJwk(jwk: PublicJwk): KeyObject {\n  if (jwk.kty !== 'EC' || jwk.crv !== USER_TOKEN_CURVE) {\n    throw new Error(`Unsupported JWKS entry: ${jwk.kty}/${jwk.crv}`);\n  }\n  if (jwk.use !== undefined && jwk.use !== 'sig') throw new Error('JWKS entry is not a signing key');\n  if (jwk.alg !== undefined && jwk.alg !== USER_TOKEN_ALGORITHM) throw new Error(`JWKS entry algorithm is not ${USER_TOKEN_ALGORITHM}`);\n  return crypto.createPublicKey({ key: { kty: 'EC', crv: jwk.crv, x: jwk.x, y: jwk.y }, format: 'jwk' });\n}\n\n/** True when `value` is shaped like the JWKS document (keys array of objects). */\nexport function isJwksDocument(value: unknown): value is JwksDocument {\n  return !!value\n    && typeof value === 'object'\n    && Array.isArray((value as { keys?: unknown }).keys)\n    && (value as { keys: unknown[] }).keys.every((k) => !!k && typeof k === 'object');\n}\n\n/**\n * Convert an ECDSA signature from ASN.1 DER (what AWS KMS returns) to the raw\n * fixed-width `r || s` JOSE form a JWT carries.\n *\n * DER is `SEQUENCE { INTEGER r, INTEGER s }` with both integers minimally\n * encoded and sign-padded; JOSE wants each coordinate left-zero-padded to\n * exactly the curve size (32 bytes for P-256). Getting this wrong produces\n * tokens that verify nowhere, so it is strict: any structural surprise throws.\n */\nexport function derToJoseSignature(der: Buffer, coordinateBytes = 32): Buffer {\n  if (der[0] !== 0x30) throw new Error('Malformed DER signature: expected SEQUENCE');\n  // Length byte(s): short form (<0x80) or long form (0x81 for a 1-byte length).\n  let offset = 1;\n  if (der[offset] === 0x81) offset += 2;\n  else if (der[offset] < 0x80) offset += 1;\n  else throw new Error('Malformed DER signature: unsupported length encoding');\n\n  const readInt = (): Buffer => {\n    if (der[offset] !== 0x02) throw new Error('Malformed DER signature: expected INTEGER');\n    const len = der[offset + 1];\n    const start = offset + 2;\n    offset = start + len;\n    let value = der.subarray(start, offset);\n    // Strip the sign-padding byte DER adds when the high bit is set…\n    while (value.length > coordinateBytes && value[0] === 0x00) value = value.subarray(1);\n    if (value.length > coordinateBytes) throw new Error('Malformed DER signature: coordinate too large');\n    // …then left-pad back out to the fixed curve width JOSE requires.\n    return Buffer.concat([Buffer.alloc(coordinateBytes - value.length), value]);\n  };\n\n  const r = readInt();\n  const s = readInt();\n  return Buffer.concat([r, s]);\n}\n"]}

package/lib/utils/logger.d.ts

@@ -30,7 +30,10 @@ export declare function redactSensitive(value: unknown): unknown;
  * logger.error('Database error', { error: err.message });
  * ```
  */
-export declare function createLogger(serviceName: string): winston.Logger;
+/** The logger `createLogger` returns. Exported so consumers can annotate exported
+ *  loggers without depending on winston themselves. */
+export type Logger = winston.Logger;
+export declare function createLogger(serviceName: string): Logger;
 /**
  * Default logger instance (service name from SERVICE_NAME env var or 'api').
  */

package/lib/utils/logger.js

@@ -110,27 +110,6 @@ const redactFormat = winston.format((info) => {
     }
     return info;
 })();
-/**
- * Create a logger instance for a service.
- *
- * When LOG_FORMAT=json (default), outputs structured JSON for Loki ingestion:
- *   {"level":"info","message":"Server started","service":"pipeline","timestamp":"..."}
- *
- * When LOG_FORMAT=text, outputs colorized human-readable format:
- *   2026-02-13T10:30:00.000Z info [pipeline] Server started
- *
- * @param serviceName - Name of the service for log identification
- * @returns Configured Winston logger instance
- *
- * @example
- * ```typescript
- * import { createLogger } from '@pipeline-builder/api-core';
- *
- * const logger = createLogger('get-plugin');
- * logger.info('Server started', { port: 3000 });
- * logger.error('Database error', { error: err.message });
- * ```
- */
 export function createLogger(serviceName) {
     const logLevel = process.env.LOG_LEVEL || 'info';
     const logFormat = process.env.LOG_FORMAT || 'json';
@@ -171,4 +150,4 @@ export function createLogger(serviceName) {
  */
 export const logger = createLogger(process.env.SERVICE_NAME || 'api');
 export default logger;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport winston from 'winston';\nimport { safeCreateRequire } from './safe-require.js';\n\nconst { combine, timestamp, printf, colorize, errors, json } = winston.format;\n\n// ESM has no global `require`; safeCreateRequire enables the synchronous,\n// OPTIONAL lazy-load of @opentelemetry/api in getCurrentTraceId() below — a\n// winston format callback must stay synchronous, so a dynamic import() won't\n// work there. (CJS-bundle safe — see safe-require.ts.)\nconst require = safeCreateRequire(import.meta.url);\n\n/**\n * Custom log format for human-readable console output.\n */\nconst consoleFormat = printf(({ level, message, timestamp, service, ...meta }) => {\n  const serviceName = service ? `[${service}]` : '';\n  const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : '';\n  return `${timestamp} ${level} ${serviceName} ${message}${metaStr}`;\n});\n\n/**\n * Lazy lookup of OpenTelemetry trace ID. Returns undefined when tracing\n * isn't initialized or @opentelemetry/api isn't installed — never throws.\n * Cheap: a single property read after the first successful lookup.\n */\nlet _otelApi: { trace?: { getActiveSpan(): { spanContext(): { traceId: string } } | undefined } } | null | undefined;\nfunction getCurrentTraceId(): string | undefined {\n  if (_otelApi === undefined) {\n    try {\n      // eslint-disable-next-line @typescript-eslint/no-require-imports\n      _otelApi = require('@opentelemetry/api');\n    } catch {\n      _otelApi = null;\n    }\n  }\n  if (!_otelApi) return undefined;\n  try {\n    return _otelApi.trace?.getActiveSpan()?.spanContext().traceId;\n  } catch {\n    return undefined;\n  }\n}\n\n/** Winston format that stamps `trace_id` on every entry when an OTel span is active. */\nconst traceIdFormat = winston.format((info) => {\n  const traceId = getCurrentTraceId();\n  if (traceId) info.trace_id = traceId;\n  return info;\n})();\n\n/**\n * Keys that should never appear in logs. Match is case-insensitive and\n * anchored substring — `Authorization`, `auth_header`, `MY_PASSWORD` all hit.\n * Add a new term here only if you've seen real-world leakage; over-redaction\n * makes incident debugging harder.\n */\nconst SENSITIVE_KEY_PATTERN = /password|secret|bearer|api[_-]?key|cookie|token|^auth(orization|_header)?$|stripe[_-]?(key|secret)|mongo(db)?[_-]?uri/i;\nconst REDACTED = '[REDACTED]';\n\nfunction redactDeep(value: unknown, depth = 0): unknown {\n  // Cap depth so a malicious / pathological circular object can't lock the logger.\n  // Degrade to a placeholder rather than the raw subtree: returning `value` here\n  // would log a secret-keyed field nested deeper than the cap in cleartext.\n  if (depth > 6) return '[TRUNCATED]';\n  if (value == null || typeof value !== 'object') return value;\n  if (Array.isArray(value)) return value.map((v) => redactDeep(v, depth + 1));\n  const out: Record<string, unknown> = {};\n  for (const [k, v] of Object.entries(value as Record<string, unknown>)) {\n    if (SENSITIVE_KEY_PATTERN.test(k)) {\n      out[k] = REDACTED;\n    } else {\n      out[k] = redactDeep(v, depth + 1);\n    }\n  }\n  return out;\n}\n\n/**\n * Redact sensitive values from an ARBITRARY payload using the same key-pattern\n * rules the Winston `redactFormat` applies to log metadata. Use this for\n * payloads that reach an output channel OUTSIDE the logger — e.g. an SSE frame\n * pushed straight to a client — so a `password`/`token`/`secret` field is\n * masked there too. A top-level sensitive key is masked; nested objects/arrays\n * are walked (depth-capped) exactly as in the logger. Returns a redacted COPY;\n * primitives pass through unchanged.\n */\nexport function redactSensitive(value: unknown): unknown {\n  if (value == null || typeof value !== 'object') return value;\n  return redactDeep(value);\n}\n\n/** Winston format that masks values for sensitive-looking keys (PII / secrets).\n * Mutates `info` in place so winston's internal Symbol-keyed properties\n * (`Symbol.for('level')`, `Symbol.for('message')`, `Symbol.for('splat')`) survive\n * — rebuilding a fresh object via `Object.entries`/spread silently strips them,\n * which makes the Console transport drop every entry without warning. */\nconst PRESERVED_KEYS = new Set(['level', 'message', 'timestamp', 'service', 'trace_id']);\nconst redactFormat = winston.format((info) => {\n  for (const key of Object.keys(info)) {\n    if (PRESERVED_KEYS.has(key)) continue;\n    if (SENSITIVE_KEY_PATTERN.test(key)) {\n      info[key] = REDACTED;\n    } else {\n      info[key] = redactDeep(info[key]);\n    }\n  }\n  return info;\n})();\n\n/**\n * Create a logger instance for a service.\n *\n * When LOG_FORMAT=json (default), outputs structured JSON for Loki ingestion:\n *   {\"level\":\"info\",\"message\":\"Server started\",\"service\":\"pipeline\",\"timestamp\":\"...\"}\n *\n * When LOG_FORMAT=text, outputs colorized human-readable format:\n *   2026-02-13T10:30:00.000Z info [pipeline] Server started\n *\n * @param serviceName - Name of the service for log identification\n * @returns Configured Winston logger instance\n *\n * @example\n * ```typescript\n * import { createLogger } from '@pipeline-builder/api-core';\n *\n * const logger = createLogger('get-plugin');\n * logger.info('Server started', { port: 3000 });\n * logger.error('Database error', { error: err.message });\n * ```\n */\nexport function createLogger(serviceName: string): winston.Logger {\n  const logLevel = process.env.LOG_LEVEL || 'info';\n  const logFormat = process.env.LOG_FORMAT || 'json';\n  if (logFormat !== 'json' && logFormat !== 'text') {\n    // eslint-disable-next-line no-console -- startup warning before logger is available\n    console.warn(`Invalid LOG_FORMAT=\"${logFormat}\", expected \"json\" or \"text\". Defaulting to \"json\".`);\n  }\n  const useJson = logFormat !== 'text';\n\n  // Order matters: redact BEFORE serialization so masked keys never reach\n  // the output. trace_id is stamped first so it survives redaction.\n  const baseFormats = [\n    errors({ stack: true }),\n    timestamp({ format: 'YYYY-MM-DDTHH:mm:ss.SSSZ' }),\n    traceIdFormat,\n    redactFormat,\n  ];\n\n  if (useJson) {\n    return winston.createLogger({\n      level: logLevel,\n      defaultMeta: { service: serviceName },\n      format: combine(...baseFormats, json()),\n      transports: [new winston.transports.Console()],\n    });\n  }\n\n  return winston.createLogger({\n    level: logLevel,\n    defaultMeta: { service: serviceName },\n    format: combine(...baseFormats),\n    transports: [\n      new winston.transports.Console({\n        format: combine(colorize(), consoleFormat),\n      }),\n    ],\n  });\n}\n\n/**\n * Default logger instance (service name from SERVICE_NAME env var or 'api').\n */\nexport const logger = createLogger(process.env.SERVICE_NAME || 'api');\n\nexport default logger;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport winston from 'winston';\nimport { safeCreateRequire } from './safe-require.js';\n\nconst { combine, timestamp, printf, colorize, errors, json } = winston.format;\n\n// ESM has no global `require`; safeCreateRequire enables the synchronous,\n// OPTIONAL lazy-load of @opentelemetry/api in getCurrentTraceId() below — a\n// winston format callback must stay synchronous, so a dynamic import() won't\n// work there. (CJS-bundle safe — see safe-require.ts.)\nconst require = safeCreateRequire(import.meta.url);\n\n/**\n * Custom log format for human-readable console output.\n */\nconst consoleFormat = printf(({ level, message, timestamp, service, ...meta }) => {\n  const serviceName = service ? `[${service}]` : '';\n  const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : '';\n  return `${timestamp} ${level} ${serviceName} ${message}${metaStr}`;\n});\n\n/**\n * Lazy lookup of OpenTelemetry trace ID. Returns undefined when tracing\n * isn't initialized or @opentelemetry/api isn't installed — never throws.\n * Cheap: a single property read after the first successful lookup.\n */\nlet _otelApi: { trace?: { getActiveSpan(): { spanContext(): { traceId: string } } | undefined } } | null | undefined;\nfunction getCurrentTraceId(): string | undefined {\n  if (_otelApi === undefined) {\n    try {\n      // eslint-disable-next-line @typescript-eslint/no-require-imports\n      _otelApi = require('@opentelemetry/api');\n    } catch {\n      _otelApi = null;\n    }\n  }\n  if (!_otelApi) return undefined;\n  try {\n    return _otelApi.trace?.getActiveSpan()?.spanContext().traceId;\n  } catch {\n    return undefined;\n  }\n}\n\n/** Winston format that stamps `trace_id` on every entry when an OTel span is active. */\nconst traceIdFormat = winston.format((info) => {\n  const traceId = getCurrentTraceId();\n  if (traceId) info.trace_id = traceId;\n  return info;\n})();\n\n/**\n * Keys that should never appear in logs. Match is case-insensitive and\n * anchored substring — `Authorization`, `auth_header`, `MY_PASSWORD` all hit.\n * Add a new term here only if you've seen real-world leakage; over-redaction\n * makes incident debugging harder.\n */\nconst SENSITIVE_KEY_PATTERN = /password|secret|bearer|api[_-]?key|cookie|token|^auth(orization|_header)?$|stripe[_-]?(key|secret)|mongo(db)?[_-]?uri/i;\nconst REDACTED = '[REDACTED]';\n\nfunction redactDeep(value: unknown, depth = 0): unknown {\n  // Cap depth so a malicious / pathological circular object can't lock the logger.\n  // Degrade to a placeholder rather than the raw subtree: returning `value` here\n  // would log a secret-keyed field nested deeper than the cap in cleartext.\n  if (depth > 6) return '[TRUNCATED]';\n  if (value == null || typeof value !== 'object') return value;\n  if (Array.isArray(value)) return value.map((v) => redactDeep(v, depth + 1));\n  const out: Record<string, unknown> = {};\n  for (const [k, v] of Object.entries(value as Record<string, unknown>)) {\n    if (SENSITIVE_KEY_PATTERN.test(k)) {\n      out[k] = REDACTED;\n    } else {\n      out[k] = redactDeep(v, depth + 1);\n    }\n  }\n  return out;\n}\n\n/**\n * Redact sensitive values from an ARBITRARY payload using the same key-pattern\n * rules the Winston `redactFormat` applies to log metadata. Use this for\n * payloads that reach an output channel OUTSIDE the logger — e.g. an SSE frame\n * pushed straight to a client — so a `password`/`token`/`secret` field is\n * masked there too. A top-level sensitive key is masked; nested objects/arrays\n * are walked (depth-capped) exactly as in the logger. Returns a redacted COPY;\n * primitives pass through unchanged.\n */\nexport function redactSensitive(value: unknown): unknown {\n  if (value == null || typeof value !== 'object') return value;\n  return redactDeep(value);\n}\n\n/** Winston format that masks values for sensitive-looking keys (PII / secrets).\n * Mutates `info` in place so winston's internal Symbol-keyed properties\n * (`Symbol.for('level')`, `Symbol.for('message')`, `Symbol.for('splat')`) survive\n * — rebuilding a fresh object via `Object.entries`/spread silently strips them,\n * which makes the Console transport drop every entry without warning. */\nconst PRESERVED_KEYS = new Set(['level', 'message', 'timestamp', 'service', 'trace_id']);\nconst redactFormat = winston.format((info) => {\n  for (const key of Object.keys(info)) {\n    if (PRESERVED_KEYS.has(key)) continue;\n    if (SENSITIVE_KEY_PATTERN.test(key)) {\n      info[key] = REDACTED;\n    } else {\n      info[key] = redactDeep(info[key]);\n    }\n  }\n  return info;\n})();\n\n/**\n * Create a logger instance for a service.\n *\n * When LOG_FORMAT=json (default), outputs structured JSON for Loki ingestion:\n *   {\"level\":\"info\",\"message\":\"Server started\",\"service\":\"pipeline\",\"timestamp\":\"...\"}\n *\n * When LOG_FORMAT=text, outputs colorized human-readable format:\n *   2026-02-13T10:30:00.000Z info [pipeline] Server started\n *\n * @param serviceName - Name of the service for log identification\n * @returns Configured Winston logger instance\n *\n * @example\n * ```typescript\n * import { createLogger } from '@pipeline-builder/api-core';\n *\n * const logger = createLogger('get-plugin');\n * logger.info('Server started', { port: 3000 });\n * logger.error('Database error', { error: err.message });\n * ```\n */\n/** The logger `createLogger` returns. Exported so consumers can annotate exported\n *  loggers without depending on winston themselves. */\nexport type Logger = winston.Logger;\n\nexport function createLogger(serviceName: string): Logger {\n  const logLevel = process.env.LOG_LEVEL || 'info';\n  const logFormat = process.env.LOG_FORMAT || 'json';\n  if (logFormat !== 'json' && logFormat !== 'text') {\n    // eslint-disable-next-line no-console -- startup warning before logger is available\n    console.warn(`Invalid LOG_FORMAT=\"${logFormat}\", expected \"json\" or \"text\". Defaulting to \"json\".`);\n  }\n  const useJson = logFormat !== 'text';\n\n  // Order matters: redact BEFORE serialization so masked keys never reach\n  // the output. trace_id is stamped first so it survives redaction.\n  const baseFormats = [\n    errors({ stack: true }),\n    timestamp({ format: 'YYYY-MM-DDTHH:mm:ss.SSSZ' }),\n    traceIdFormat,\n    redactFormat,\n  ];\n\n  if (useJson) {\n    return winston.createLogger({\n      level: logLevel,\n      defaultMeta: { service: serviceName },\n      format: combine(...baseFormats, json()),\n      transports: [new winston.transports.Console()],\n    });\n  }\n\n  return winston.createLogger({\n    level: logLevel,\n    defaultMeta: { service: serviceName },\n    format: combine(...baseFormats),\n    transports: [\n      new winston.transports.Console({\n        format: combine(colorize(), consoleFormat),\n      }),\n    ],\n  });\n}\n\n/**\n * Default logger instance (service name from SERVICE_NAME env var or 'api').\n */\nexport const logger = createLogger(process.env.SERVICE_NAME || 'api');\n\nexport default logger;\n"]}

package/lib/utils/secret-encryption.d.ts

@@ -67,7 +67,9 @@ export declare class KmsKeyProvider implements KeyProvider {
  *  one. Triggers lazy initialization on first access, same as the internal
  *  callers below. */
 export declare function getDefaultKeyProvider(): KeyProvider;
-/** Reset the cached default provider  for tests that mutate `process.env`. */
+/** Read the rotation-fallback provider (null outside a master-key rotation). */
+export declare function getPreviousKeyProvider(): KeyProvider | null;
+/** Reset the cached default (and previous) provider  for tests that mutate `process.env`. */
 export declare function resetDefaultKeyProvider(): void;
 /** Replace the default provider  services that opt into KMS call this
  * once at startup with a warmed-up `KmsKeyProvider`. */
@@ -181,8 +183,11 @@ export declare function encryptSecret(plaintext: string, orgId: string, provider
  *
  * Callers handle the throw  masking the failure as `null` would hide
  * silent corruption / wrong-org reads.
+ *
+ * `previous` (default: `SECRET_ENCRYPTION_KEY_PREVIOUS`, when set) is tried
+ * only after the primary key fails, and only for kid-less blobs.
  */
-export declare function decryptSecret(blob: EncryptedBlob, orgId: string, provider?: KeyProvider): Promise<string>;
+export declare function decryptSecret(blob: EncryptedBlob, orgId: string, provider?: KeyProvider, previous?: KeyProvider | null): Promise<string>;
 /**
  * Type guard  handy for model layers that hold a column whose value may be
  * either a clear-text string (legacy / unencrypted) OR an encrypted blob

package/lib/utils/secret-encryption.js

@@ -182,8 +182,28 @@ function getDefaultProvider() {
 export function getDefaultKeyProvider() {
     return getDefaultProvider();
 }
-/** Reset the cached default provider  for tests that mutate `process.env`. */
-export function resetDefaultKeyProvider() { defaultProvider = null; }
+/**
+ * Rotation fallback: an `EnvKeyProvider` over `SECRET_ENCRYPTION_KEY_PREVIOUS`,
+ * or null when that env is unset. `undefined` = not yet resolved. While a
+ * master-key rotation is in progress, `decryptSecret` retries a failed decrypt
+ * under this key, so rows written under the old master stay readable until the
+ * re-encryption tool (platform `scripts/reencrypt-secrets.js`) has rewritten
+ * them under the new one. Encryption NEVER uses it.
+ */
+let previousProvider;
+function getPreviousProvider() {
+    if (previousProvider === undefined) {
+        const raw = process.env.SECRET_ENCRYPTION_KEY_PREVIOUS;
+        previousProvider = raw ? new EnvKeyProvider(raw) : null;
+    }
+    return previousProvider;
+}
+/** Read the rotation-fallback provider (null outside a master-key rotation). */
+export function getPreviousKeyProvider() {
+    return getPreviousProvider();
+}
+/** Reset the cached default (and previous) provider  for tests that mutate `process.env`. */
+export function resetDefaultKeyProvider() { defaultProvider = null; previousProvider = undefined; }
 /** Replace the default provider  services that opt into KMS call this
  * once at startup with a warmed-up `KmsKeyProvider`. */
 export function setKeyProvider(provider) { defaultProvider = provider; }
@@ -380,8 +400,11 @@ export async function encryptSecret(plaintext, orgId, provider = getDefaultProvi
  *
  * Callers handle the throw  masking the failure as `null` would hide
  * silent corruption / wrong-org reads.
+ *
+ * `previous` (default: `SECRET_ENCRYPTION_KEY_PREVIOUS`, when set) is tried
+ * only after the primary key fails, and only for kid-less blobs.
  */
-export async function decryptSecret(blob, orgId, provider = getDefaultProvider()) {
+export async function decryptSecret(blob, orgId, provider = getDefaultProvider(), previous = getPreviousProvider()) {
     if (blob.alg !== 'aes-256-gcm-v1') {
         throw new Error(`Unsupported encryption alg: ${blob.alg}`);
     }
@@ -396,6 +419,26 @@ export async function decryptSecret(blob, orgId, provider = getDefaultProvider()
     if (providerKid !== undefined && blob.kid !== undefined && providerKid !== blob.kid) {
         throw new Error(`KMS key id mismatch: blob was encrypted under ${blob.kid}, current provider uses ${providerKid} for org ${orgId}`);
     }
+    try {
+        return decryptWithKey(blob, key);
+    }
+    catch (err) {
+        // Master-key rotation window: retry under SECRET_ENCRYPTION_KEY_PREVIOUS.
+        // Only for a kid-less blob (the env-keyed shape) — a per-org KMS blob is
+        // bound to its CMK and the shared previous master can never open it. The
+        // ORIGINAL error surfaces when the previous key fails too, so a tampered or
+        // wrong-org blob still fails loud exactly as before.
+        if (previous && blob.kid === undefined) {
+            try {
+                return decryptWithKey(blob, await deriveKeyFor(previous, orgId));
+            }
+            catch { /* fall through to the primary error */ }
+        }
+        throw err;
+    }
+}
+/** AES-256-GCM open of a blob under one derived key. Throws on any auth-tag failure. */
+function decryptWithKey(blob, key) {
     const iv = Buffer.from(blob.iv, 'base64');
     const all = Buffer.from(blob.ciphertext, 'base64');
     // Split off the 16-byte auth tag appended in encryptSecret. Any tampering
@@ -421,4 +464,4 @@ export function isEncryptedBlob(value) {
         && typeof value.iv === 'string'
         && typeof value.ciphertext === 'string');
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"secret-encryption.js","sourceRoot":"","sources":["../../src/utils/secret-encryption.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n *  Per-org envelope encryption for secret columns.\n *\n * Today's posture for org-scoped secrets (aiProviderKeys, webhook URLs,\n * registry credentials) is clear-text in Mongo / Postgres with app-layer\n * masking on output. This module is the encryption primitive that lets the\n * model layer swap clear-text strings for `EncryptedBlob` values at write\n * time and decrypt at read time.\n *\n * Cryptography * - AES-256-GCM (authenticated encryption).\n * - Per-org key derived via HKDF-SHA256(masterKey, salt=orgId, info='secrets-v1').\n * Each org gets a unique key without operator key-management ceremony.\n * - 12-byte IV generated per encryption with `crypto.randomBytes`.\n * - 16-byte authentication tag concatenated with ciphertext (standard GCM).\n *\n * Operator configuration * - `SECRET_ENCRYPTION_KEY` env: hex- or base64-encoded 32-byte master key.\n * Required when `encryptSecret`/`decryptSecret` are called. Missing key\n * throws  encryption is fail-closed; we never silently round-trip a\n * secret as plaintext.\n *\n * KMS migration path * - The two exported functions take a `provider` parameter. The default\n * `EnvKeyProvider` implements HKDF derivation. A future `AwsKmsProvider`\n * plugs in here: it can call KMS `Encrypt` / `Decrypt` to wrap a DEK\n * rather than holding a master key in env. The on-disk blob shape\n * (`{ alg, iv, ciphertext, kid? }`) is forward-compatible  `kid`\n * carries the KMS key id when the provider needs it.\n */\n\nimport { createCipheriv, createDecipheriv, hkdfSync, randomBytes } from 'crypto';\n\n/** On-disk shape of an encrypted secret. JSON-serializable. */\nexport interface EncryptedBlob {\n  /** Algorithm tag. Bump on format change so a future migration can detect old blobs. */\n  alg: 'aes-256-gcm-v1';\n  /** Base64-encoded 12-byte IV. */\n  iv: string;\n  /** Base64-encoded ciphertext + 16-byte authentication tag concatenated. */\n  ciphertext: string;\n  /** Optional key id  populated by KMS-backed providers, ignored by the env provider. */\n  kid?: string;\n}\n\n/** Pluggable key source. Env-backed by default; KMS-backed available. */\nexport interface KeyProvider {\n  /** Derive a 32-byte symmetric key bound to `orgId`. */\n  deriveKey(orgId: string): Buffer;\n  /** Optional async variant for providers that need to do I/O (e.g.\n   *  per-org KMS lookup the first time an org is seen). Default\n   *  implementation forwards to the sync `deriveKey`. */\n  deriveKeyAsync?(orgId: string): Promise<Buffer>;\n  /** Optional KMS-key-id this provider used for `orgId`. Embedded in the\n   *  `EncryptedBlob.kid` field on write so decrypt can verify the right\n   *  KMS CMK is being used (defense against an attacker who swaps a blob\n   *  between orgs). Default returns undefined (env provider). */\n  kidFor?(orgId: string): string | undefined;\n}\n\n/**\n * Default provider  derives a per-org key from `SECRET_ENCRYPTION_KEY` via\n * HKDF-SHA256. Suitable for self-hosted / dev where operators don't have KMS.\n *\n * Fails fast if the env is missing or the key is the wrong length so misconfig\n * surfaces at first use rather than silently fingerprinting all writes with\n * a default zero key.\n */\nexport class EnvKeyProvider implements KeyProvider {\n  private readonly masterKey: Buffer;\n\n  constructor(masterKeyOverride?: string) {\n    const raw = masterKeyOverride ?? process.env.SECRET_ENCRYPTION_KEY;\n    if (!raw) {\n      throw new Error('SECRET_ENCRYPTION_KEY env is required for secret encryption');\n    }\n    // Accept either hex (64 chars) or base64 (44 chars including padding) for\n    // operator convenience  both decode to a 32-byte key.\n    const decoded = raw.length === 64 && /^[0-9a-f]+$/i.test(raw)\n      ? Buffer.from(raw, 'hex')\n      : Buffer.from(raw, 'base64');\n    if (decoded.length !== 32) {\n      throw new Error(`SECRET_ENCRYPTION_KEY must decode to 32 bytes (got ${decoded.length})`);\n    }\n    this.masterKey = decoded;\n  }\n\n  deriveKey(orgId: string): Buffer {\n    // HKDF binds the master key to the org so two orgs encrypting the same\n    // plaintext produce different ciphertexts  keeps a stolen DB unable to\n    // tell which orgs share secrets via ciphertext comparison.\n    const derived = hkdfSync( 'sha256',\n      this.masterKey,\n      Buffer.from(orgId, 'utf8'),\n      'secrets-v1',\n      32,\n    );\n    // hkdfSync returns ArrayBuffer in older Node typings; normalize to Buffer.\n    return Buffer.from(derived);\n  }\n}\n\n/**\n *  AWS-KMS-backed KeyProvider.\n *\n * Trade-off picked: store ONE master key encrypted under a KMS CMK; on\n * first use, call `kms:Decrypt` to recover the master key bytes; HKDF-\n * derive per-org from it (same as EnvKeyProvider). The process then holds\n * the plaintext master key in memory until restart.\n *\n * PROS: one KMS call per process lifetime (cheap, low p99 impact),\n * the encrypted-master-key blob is safe to commit/log/checkin,\n * KMS audit log records when the master is recovered.\n * CONS: process memory still holds the master key  same posture as\n * EnvKeyProvider once warmed up. For stronger isolation an\n * operator can move to per-record envelope encryption (call\n * GenerateDataKey on every write); that's a follow-on.\n *\n * Operator setup * 1. Create a KMS CMK with key policy allowing the platform service's\n * IAM role kms:Decrypt.\n * 2. Generate a random 32-byte master * head -c 32 /dev/urandom | base64\n * 3. Wrap it with KMS * aws kms encrypt --key-id <KEY_ID> \\\n * --plaintext <base64-from-step-2> --output text \\\n * --query CiphertextBlob\n * 4. Set on the service * SECRET_ENCRYPTION_KMS_KEY_ID=<KEY_ID>\n * SECRET_ENCRYPTION_KMS_CIPHERTEXT=<base64-output-of-step-3>\n * 5. Pick this provider via `setKeyProvider(new KmsKeyProvider())`.\n *\n * Construct lazily  importing the AWS SDK has a non-trivial cold-start\n * cost so envs that stay on EnvKeyProvider never load it.\n */\n/**\n * KMS-decrypt a base64 ciphertext into a 32-byte key. Shared by both KMS key\n * providers (single-master + per-org), which previously copy-pasted this\n * dynamic-import + Decrypt + empty/length guards. `@aws-sdk/client-kms` is\n * dynamically imported so EnvKeyProvider-only envs never load the SDK.\n */\nasync function kmsDecrypt32(keyId: string, ciphertextB64: string, region?: string, endpoint?: string): Promise<Buffer> {\n  const { KMSClient, DecryptCommand } = await import('@aws-sdk/client-kms');\n  const client = new KMSClient({ region, ...(endpoint ? { endpoint } : {}) });\n  const resp = await client.send(new DecryptCommand({\n    KeyId: keyId,\n    CiphertextBlob: Buffer.from(ciphertextB64, 'base64'),\n  }));\n  if (!resp.Plaintext) throw new Error(`KMS Decrypt returned an empty Plaintext for key ${keyId}`);\n  const buf = Buffer.from(resp.Plaintext);\n  if (buf.length !== 32) throw new Error(`KMS Decrypt returned ${buf.length}-byte key for ${keyId}; expected 32`);\n  return buf;\n}\n\nexport class KmsKeyProvider implements KeyProvider {\n  private masterKeyCache: Buffer | null = null;\n  private readonly keyId: string;\n  private readonly ciphertextB64: string;\n  private readonly region?: string;\n  private readonly endpoint?: string;\n  private decryptInFlight: Promise<Buffer> | null = null;\n\n  constructor(opts?: { keyId?: string; ciphertextBase64?: string; region?: string; endpoint?: string }) {\n    const keyId = opts?.keyId ?? process.env.SECRET_ENCRYPTION_KMS_KEY_ID;\n    const ciphertext = opts?.ciphertextBase64 ?? process.env.SECRET_ENCRYPTION_KMS_CIPHERTEXT;\n    if (!keyId) throw new Error('SECRET_ENCRYPTION_KMS_KEY_ID env is required for KmsKeyProvider');\n    if (!ciphertext) throw new Error('SECRET_ENCRYPTION_KMS_CIPHERTEXT env is required for KmsKeyProvider');\n    this.keyId = keyId;\n    this.ciphertextB64 = ciphertext;\n    this.region = opts?.region ?? process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION;\n    this.endpoint = opts?.endpoint ?? process.env.AWS_KMS_ENDPOINT;\n  }\n\n  deriveKey(orgId: string): Buffer {\n    if (!this.masterKeyCache) {\n      throw new Error( 'KmsKeyProvider is not warmed up. Call `await provider.warmup()` once at service startup before any encrypt/decrypt.',\n      );\n    }\n    const derived = hkdfSync('sha256', this.masterKeyCache, Buffer.from(orgId, 'utf8'), 'secrets-v1', 32);\n    return Buffer.from(derived);\n  }\n\n  /**\n   * Eagerly recover the master key from KMS so subsequent `deriveKey`\n   * calls are sync. Idempotent  concurrent callers share the same in-\n   * flight promise so we don't spawn multiple KMS Decrypt requests at\n   * boot. Throws on any KMS failure; the caller (typically the service's\n   * onBeforeStart hook) decides whether to fall back to a different\n   * provider or fail-startup.\n   */\n  async warmup(): Promise<void> {\n    if (this.masterKeyCache) return;\n    if (!this.decryptInFlight) {\n      this.decryptInFlight = this.fetchAndDecrypt();\n    }\n    try {\n      this.masterKeyCache = await this.decryptInFlight;\n    } catch (err) {\n      // A transient KMS failure must not permanently poison the provider: clear\n      // the rejected in-flight promise so a later warmup() retries instead of\n      // re-awaiting the same rejection forever (matches PerOrgKmsKeyProvider).\n      this.decryptInFlight = null;\n      throw err;\n    }\n  }\n\n  private fetchAndDecrypt(): Promise<Buffer> {\n    return kmsDecrypt32(this.keyId, this.ciphertextB64, this.region, this.endpoint);\n  }\n}\n\n// Lazy singleton  operator code in long-lived services pays the env-parse\n// cost once, and tests can mint their own provider with a literal key.\nlet defaultProvider: KeyProvider | null = null;\nfunction getDefaultProvider(): KeyProvider {\n  if (!defaultProvider) defaultProvider = new EnvKeyProvider();\n  return defaultProvider;\n}\n\n/** Read the active default provider. Exposed so service code (e.g. an\n *  admin endpoint that just rotated an org's KMS config) can call\n *  `provider.evict(orgId)` on the live provider rather than reconstructing\n *  one. Triggers lazy initialization on first access, same as the internal\n *  callers below. */\nexport function getDefaultKeyProvider(): KeyProvider {\n  return getDefaultProvider();\n}\n\n/** Reset the cached default provider  for tests that mutate `process.env`. */\nexport function resetDefaultKeyProvider(): void { defaultProvider = null; }\n\n/** Replace the default provider  services that opt into KMS call this\n * once at startup with a warmed-up `KmsKeyProvider`. */\nexport function setKeyProvider(provider: KeyProvider): void { defaultProvider = provider; }\n\n/** Per-org KMS config the operator supplies. The `keyId` identifies the\n *  KMS CMK to call Decrypt on; `ciphertextBase64` is the wrapped 32-byte\n *  master generated by `aws kms encrypt` against that key. */\nexport interface PerOrgKmsConfig {\n  keyId: string;\n  ciphertextBase64: string;\n}\n\n/**\n * Async resolver that maps an org id to its KMS config. Returns `null` when\n * the org has no per-org config — the provider then falls back to the\n * `fallback` provider supplied at construction (usually an EnvKeyProvider\n * or a default KmsKeyProvider).\n */\nexport type PerOrgKmsResolver = (orgId: string) => Promise<PerOrgKmsConfig | null>;\n\n/**\n * Per-org KMS-backed KeyProvider. The blast radius of a KMS key compromise\n * is one org instead of every org under a shared master.\n *\n * Each org has its own KMS CMK + its own wrapped master (stored in Mongo\n * via the operator's setup script). On first encrypt/decrypt for an org,\n * the provider:\n *   1. Calls the resolver to fetch the org's KMS config.\n *   2. Calls `kms:Decrypt` to recover the 32-byte master.\n *   3. Caches the recovered master in-memory for the process lifetime.\n *   4. HKDF-derives per-call from that master + the org id salt.\n *\n * Blobs encrypted by this provider carry `kid = <kms-key-id>` so the\n * decrypt path detects a stale config (operator rotated the key but\n * existing rows weren't re-encrypted) BEFORE AES-GCM throws an opaque\n * authentication-tag error.\n *\n * Orgs without per-org config fall through to the `fallback` provider —\n * mixed-mode deployments where some orgs have KMS isolation and others\n * stay on the shared master are explicitly supported.\n */\nexport class PerOrgKmsKeyProvider implements KeyProvider {\n  /** Cached per-org master keys, keyed by orgId. */\n  private readonly masters = new Map<string, { key: Buffer; kid: string }>();\n  /** Resolved per-org configs cached for the process lifetime. */\n  private readonly configs = new Map<string, PerOrgKmsConfig>();\n  /** In-flight resolver promises so concurrent first-touch callers share one KMS Decrypt.\n   *  Resolves to `null` for orgs with no per-org config — caller treats null as\n   *  \"fall through to the fallback provider\", same as a cold cache miss. */\n  private readonly inFlight = new Map<string, Promise<{ key: Buffer; kid: string } | null>>();\n  /** Orgs the resolver has PROVEN have no per-org config — the fallback provider\n   *  is the correct answer for these, and `deriveKey` may serve them\n   *  synchronously. Distinct from \"not yet resolved\", which must not guess. */\n  private readonly resolvedNoPerOrgConfig = new Set<string>();\n  /** Provider used for orgs that have no per-org config. */\n  private readonly fallback: KeyProvider;\n  private readonly resolver: PerOrgKmsResolver;\n  private readonly region?: string;\n  private readonly endpoint?: string;\n\n  constructor(opts: {\n    resolver: PerOrgKmsResolver;\n    fallback: KeyProvider;\n    region?: string;\n    endpoint?: string;\n  }) {\n    this.resolver = opts.resolver;\n    this.fallback = opts.fallback;\n    this.region = opts.region ?? process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION;\n    this.endpoint = opts.endpoint ?? process.env.AWS_KMS_ENDPOINT;\n  }\n\n  /**\n   * Sync derive. Only correct for an org whose config has already been\n   * RESOLVED — either it has a per-org master (use it) or it provably has no\n   * per-org config (the fallback is then the right answer).\n   *\n   * For an UNRESOLVED org this THROWS rather than guessing. It used to fall\n   * through to the fallback, which silently encrypted that org's secrets under\n   * the SHARED master and — because `kidFor` also returned undefined, so the\n   * both-kids-present mismatch guard could never fire — left them permanently\n   * undecryptable once the org warmed: `decipher.final()` then threw an opaque\n   * auth-tag error with no diagnostic. Failing loud here matches\n   * `KmsKeyProvider.deriveKey`, which has always refused to work cold.\n   *\n   * `encryptSecret`/`decryptSecret` are async and await `deriveKeyAsync`, so\n   * they resolve the org first and never hit this path; it is the backstop for\n   * a caller that reaches for the sync API directly.\n   */\n  deriveKey(orgId: string): Buffer {\n    const cached = this.masters.get(orgId);\n    if (!cached) {\n      if (this.resolvedNoPerOrgConfig.has(orgId)) return this.fallback.deriveKey(orgId);\n      throw new Error( `PerOrgKmsKeyProvider has not resolved org ${orgId}. `\n        + 'Call `await provider.ensureWarmed(orgId)` (or use the async encryptSecret/decryptSecret) '\n        + 'before deriving a key — guessing the shared master would write secrets that cannot be decrypted later.',\n      );\n    }\n    const derived = hkdfSync('sha256', cached.key, Buffer.from(orgId, 'utf8'), 'secrets-v1', 32);\n    return Buffer.from(derived);\n  }\n\n  async deriveKeyAsync(orgId: string): Promise<Buffer> {\n    await this.ensureWarmed(orgId);\n    return this.deriveKey(orgId);\n  }\n\n  kidFor(orgId: string): string | undefined {\n    const cached = this.masters.get(orgId);\n    if (cached) return cached.kid;\n    // Only speak for an org whose config is resolved; an unresolved org has no\n    // meaningful kid, and claiming one would defeat the mismatch guard.\n    if (this.resolvedNoPerOrgConfig.has(orgId)) return this.fallback.kidFor?.(orgId);\n    return undefined;\n  }\n\n  /**\n   * Resolve the org's KMS config, call Decrypt, cache the master. Subsequent\n   * calls for the same org are no-ops. Concurrent callers share the in-flight\n   * Decrypt promise.\n   *\n   * Returns silently when the org has no per-org config — the fallback\n   * provider handles those orgs.\n   */\n  async ensureWarmed(orgId: string): Promise<void> {\n    if (this.masters.has(orgId)) return;\n    // Install the in-flight promise SYNCHRONOUSLY before yielding so concurrent\n    // callers find it on the second-and-later passes. Awaiting the resolver\n    // before populating the map is the bug that lets a Promise.all of 3\n    // callers fire 3 KMS Decrypts.\n    let promise = this.inFlight.get(orgId);\n    if (!promise) {\n      promise = this.resolveAndDecrypt(orgId);\n      this.inFlight.set(orgId, promise);\n      void promise.finally(() => { if (this.inFlight.get(orgId) === promise) this.inFlight.delete(orgId); });\n    }\n    const result = await promise;\n    if (result) this.masters.set(orgId, result);\n    // Remember the NEGATIVE outcome too, so the sync `deriveKey` can tell\n    // \"no per-org config, fallback is correct\" from \"not resolved yet\".\n    else this.resolvedNoPerOrgConfig.add(orgId);\n  }\n\n  private async resolveAndDecrypt(orgId: string): Promise<{ key: Buffer; kid: string } | null> {\n    let cfg = this.configs.get(orgId);\n    if (!cfg) {\n      const resolved = await this.resolver(orgId);\n      if (!resolved) return null; // no per-org config → caller uses fallback\n      cfg = resolved;\n      this.configs.set(orgId, cfg);\n    }\n    const key = await this.fetchAndDecrypt(cfg);\n    return { key, kid: cfg.keyId };\n  }\n\n  private fetchAndDecrypt(cfg: PerOrgKmsConfig): Promise<Buffer> {\n    return kmsDecrypt32(cfg.keyId, cfg.ciphertextBase64, this.region, this.endpoint);\n  }\n\n  /** Evict a cached per-org master. Use after a key rotation so the next\n   *  touch re-fetches the new wrapped master from the resolver. */\n  evict(orgId: string): void {\n    this.masters.delete(orgId);\n    this.configs.delete(orgId);\n    // Also forget a NEGATIVE resolution, or an org that gains a per-org config\n    // after being resolved as \"no config\" would keep using the shared master.\n    this.resolvedNoPerOrgConfig.delete(orgId);\n  }\n}\n\n/**\n * Derive the key for `orgId`, giving the provider a chance to do I/O first.\n *\n * This is why `encryptSecret`/`decryptSecret` are async: `PerOrgKmsKeyProvider`\n * needs one KMS Decrypt the first time it sees an org, and deriving\n * synchronously before that resolves would silently fall back to the shared\n * master and produce secrets that cannot be decrypted afterwards.\n */\nasync function deriveKeyFor(provider: KeyProvider, orgId: string): Promise<Buffer> {\n  return provider.deriveKeyAsync ? provider.deriveKeyAsync(orgId) : provider.deriveKey(orgId);\n}\n\n/**\n * Encrypt a plaintext string for storage. Returns an `EncryptedBlob` that\n * can be JSON-serialized into the underlying column / Mongo document.\n *\n * Empty strings round-trip as `null` so the calling model layer can treat\n * \"no secret set\" identically to \"field absent\".\n */\nexport async function encryptSecret( plaintext: string,\n  orgId: string,\n  provider: KeyProvider = getDefaultProvider(),\n): Promise<EncryptedBlob> {\n  if (!plaintext) {\n    throw new Error('Refusing to encrypt empty string; caller should store null instead');\n  }\n  // Resolve (and warm) the org BEFORE reading `kidFor` below, so a per-org KMS\n  // blob is always stamped with the key it was actually encrypted under.\n  const key = await deriveKeyFor(provider, orgId);\n  const iv = randomBytes(12);\n  const cipher = createCipheriv('aes-256-gcm', key, iv);\n  const enc = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);\n  const tag = cipher.getAuthTag();\n  // PerOrgKmsKeyProvider tags blobs with the KMS key id used so the\n  // decrypt path can refuse to operate if the operator later swaps in a\n  // different per-org config (a misconfigured swap shouldn't silently\n  // accept a stale blob it can't verify against the right CMK).\n  const kid = provider.kidFor?.(orgId);\n  return {\n    alg: 'aes-256-gcm-v1',\n    iv: iv.toString('base64'),\n    // GCM tag MUST travel with the ciphertext or `decryptSecret` can't\n    // verify integrity  concatenate so the on-disk shape is one field.\n    ciphertext: Buffer.concat([enc, tag]).toString('base64'),\n    ...(kid !== undefined ? { kid } : {}),\n  };\n}\n\n/**\n * Decrypt an `EncryptedBlob` written by `encryptSecret`. Throws on * - unknown `alg` (forces an explicit migration when the format changes)\n * - wrong orgId (HKDF binding mismatch fails the auth tag)\n * - tampered ciphertext (GCM auth tag check fails)\n *\n * Callers handle the throw  masking the failure as `null` would hide\n * silent corruption / wrong-org reads.\n */\nexport async function decryptSecret( blob: EncryptedBlob,\n  orgId: string,\n  provider: KeyProvider = getDefaultProvider(),\n): Promise<string> {\n  if (blob.alg !== 'aes-256-gcm-v1') {\n    throw new Error(`Unsupported encryption alg: ${blob.alg}`);\n  }\n  // Warm first: `kidFor` and `deriveKey` below must both speak for the org's\n  // real config, or the mismatch guard silently no-ops.\n  const key = await deriveKeyFor(provider, orgId);\n  // If both the provider AND the blob report a kid, they must match.\n  // Mismatch usually means an operator rotated/replaced an org's KMS\n  // config and is now reading a blob encrypted under the OLD key —\n  // failing loud here beats letting AES-GCM throw an opaque auth-tag error.\n  const providerKid = provider.kidFor?.(orgId);\n  if (providerKid !== undefined && blob.kid !== undefined && providerKid !== blob.kid) {\n    throw new Error(`KMS key id mismatch: blob was encrypted under ${blob.kid}, current provider uses ${providerKid} for org ${orgId}`);\n  }\n  const iv = Buffer.from(blob.iv, 'base64');\n  const all = Buffer.from(blob.ciphertext, 'base64');\n  // Split off the 16-byte auth tag appended in encryptSecret. Any tampering\n  //  to either the ciphertext OR the tag  causes the next `final()` to\n  // throw with \"Unsupported state or unable to authenticate data\".\n  const tag = all.subarray(all.length - 16);\n  const enc = all.subarray(0, all.length - 16);\n  const decipher = createDecipheriv('aes-256-gcm', key, iv);\n  decipher.setAuthTag(tag);\n  const dec = Buffer.concat([decipher.update(enc), decipher.final()]);\n  return dec.toString('utf8');\n}\n\n/**\n * Type guard  handy for model layers that hold a column whose value may be\n * either a clear-text string (legacy / unencrypted) OR an encrypted blob\n * (post-migration). Mixed states arise mid-migration; the model decides\n * what to do (decrypt on read, encrypt on next write).\n */\nexport function isEncryptedBlob(value: unknown): value is EncryptedBlob {\n  return ( typeof value === 'object'\n    && value !== null\n    && (value as { alg?: unknown }).alg === 'aes-256-gcm-v1'\n    && typeof (value as { iv?: unknown }).iv === 'string'\n    && typeof (value as { ciphertext?: unknown }).ciphertext === 'string'\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"secret-encryption.js","sourceRoot":"","sources":["../../src/utils/secret-encryption.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n *  Per-org envelope encryption for secret columns.\n *\n * Today's posture for org-scoped secrets (aiProviderKeys, webhook URLs,\n * registry credentials) is clear-text in Mongo / Postgres with app-layer\n * masking on output. This module is the encryption primitive that lets the\n * model layer swap clear-text strings for `EncryptedBlob` values at write\n * time and decrypt at read time.\n *\n * Cryptography * - AES-256-GCM (authenticated encryption).\n * - Per-org key derived via HKDF-SHA256(masterKey, salt=orgId, info='secrets-v1').\n * Each org gets a unique key without operator key-management ceremony.\n * - 12-byte IV generated per encryption with `crypto.randomBytes`.\n * - 16-byte authentication tag concatenated with ciphertext (standard GCM).\n *\n * Operator configuration * - `SECRET_ENCRYPTION_KEY` env: hex- or base64-encoded 32-byte master key.\n * Required when `encryptSecret`/`decryptSecret` are called. Missing key\n * throws  encryption is fail-closed; we never silently round-trip a\n * secret as plaintext.\n *\n * KMS migration path * - The two exported functions take a `provider` parameter. The default\n * `EnvKeyProvider` implements HKDF derivation. A future `AwsKmsProvider`\n * plugs in here: it can call KMS `Encrypt` / `Decrypt` to wrap a DEK\n * rather than holding a master key in env. The on-disk blob shape\n * (`{ alg, iv, ciphertext, kid? }`) is forward-compatible  `kid`\n * carries the KMS key id when the provider needs it.\n */\n\nimport { createCipheriv, createDecipheriv, hkdfSync, randomBytes } from 'crypto';\n\n/** On-disk shape of an encrypted secret. JSON-serializable. */\nexport interface EncryptedBlob {\n  /** Algorithm tag. Bump on format change so a future migration can detect old blobs. */\n  alg: 'aes-256-gcm-v1';\n  /** Base64-encoded 12-byte IV. */\n  iv: string;\n  /** Base64-encoded ciphertext + 16-byte authentication tag concatenated. */\n  ciphertext: string;\n  /** Optional key id  populated by KMS-backed providers, ignored by the env provider. */\n  kid?: string;\n}\n\n/** Pluggable key source. Env-backed by default; KMS-backed available. */\nexport interface KeyProvider {\n  /** Derive a 32-byte symmetric key bound to `orgId`. */\n  deriveKey(orgId: string): Buffer;\n  /** Optional async variant for providers that need to do I/O (e.g.\n   *  per-org KMS lookup the first time an org is seen). Default\n   *  implementation forwards to the sync `deriveKey`. */\n  deriveKeyAsync?(orgId: string): Promise<Buffer>;\n  /** Optional KMS-key-id this provider used for `orgId`. Embedded in the\n   *  `EncryptedBlob.kid` field on write so decrypt can verify the right\n   *  KMS CMK is being used (defense against an attacker who swaps a blob\n   *  between orgs). Default returns undefined (env provider). */\n  kidFor?(orgId: string): string | undefined;\n}\n\n/**\n * Default provider  derives a per-org key from `SECRET_ENCRYPTION_KEY` via\n * HKDF-SHA256. Suitable for self-hosted / dev where operators don't have KMS.\n *\n * Fails fast if the env is missing or the key is the wrong length so misconfig\n * surfaces at first use rather than silently fingerprinting all writes with\n * a default zero key.\n */\nexport class EnvKeyProvider implements KeyProvider {\n  private readonly masterKey: Buffer;\n\n  constructor(masterKeyOverride?: string) {\n    const raw = masterKeyOverride ?? process.env.SECRET_ENCRYPTION_KEY;\n    if (!raw) {\n      throw new Error('SECRET_ENCRYPTION_KEY env is required for secret encryption');\n    }\n    // Accept either hex (64 chars) or base64 (44 chars including padding) for\n    // operator convenience  both decode to a 32-byte key.\n    const decoded = raw.length === 64 && /^[0-9a-f]+$/i.test(raw)\n      ? Buffer.from(raw, 'hex')\n      : Buffer.from(raw, 'base64');\n    if (decoded.length !== 32) {\n      throw new Error(`SECRET_ENCRYPTION_KEY must decode to 32 bytes (got ${decoded.length})`);\n    }\n    this.masterKey = decoded;\n  }\n\n  deriveKey(orgId: string): Buffer {\n    // HKDF binds the master key to the org so two orgs encrypting the same\n    // plaintext produce different ciphertexts  keeps a stolen DB unable to\n    // tell which orgs share secrets via ciphertext comparison.\n    const derived = hkdfSync( 'sha256',\n      this.masterKey,\n      Buffer.from(orgId, 'utf8'),\n      'secrets-v1',\n      32,\n    );\n    // hkdfSync returns ArrayBuffer in older Node typings; normalize to Buffer.\n    return Buffer.from(derived);\n  }\n}\n\n/**\n *  AWS-KMS-backed KeyProvider.\n *\n * Trade-off picked: store ONE master key encrypted under a KMS CMK; on\n * first use, call `kms:Decrypt` to recover the master key bytes; HKDF-\n * derive per-org from it (same as EnvKeyProvider). The process then holds\n * the plaintext master key in memory until restart.\n *\n * PROS: one KMS call per process lifetime (cheap, low p99 impact),\n * the encrypted-master-key blob is safe to commit/log/checkin,\n * KMS audit log records when the master is recovered.\n * CONS: process memory still holds the master key  same posture as\n * EnvKeyProvider once warmed up. For stronger isolation an\n * operator can move to per-record envelope encryption (call\n * GenerateDataKey on every write); that's a follow-on.\n *\n * Operator setup * 1. Create a KMS CMK with key policy allowing the platform service's\n * IAM role kms:Decrypt.\n * 2. Generate a random 32-byte master * head -c 32 /dev/urandom | base64\n * 3. Wrap it with KMS * aws kms encrypt --key-id <KEY_ID> \\\n * --plaintext <base64-from-step-2> --output text \\\n * --query CiphertextBlob\n * 4. Set on the service * SECRET_ENCRYPTION_KMS_KEY_ID=<KEY_ID>\n * SECRET_ENCRYPTION_KMS_CIPHERTEXT=<base64-output-of-step-3>\n * 5. Pick this provider via `setKeyProvider(new KmsKeyProvider())`.\n *\n * Construct lazily  importing the AWS SDK has a non-trivial cold-start\n * cost so envs that stay on EnvKeyProvider never load it.\n */\n/**\n * KMS-decrypt a base64 ciphertext into a 32-byte key. Shared by both KMS key\n * providers (single-master + per-org), which previously copy-pasted this\n * dynamic-import + Decrypt + empty/length guards. `@aws-sdk/client-kms` is\n * dynamically imported so EnvKeyProvider-only envs never load the SDK.\n */\nasync function kmsDecrypt32(keyId: string, ciphertextB64: string, region?: string, endpoint?: string): Promise<Buffer> {\n  const { KMSClient, DecryptCommand } = await import('@aws-sdk/client-kms');\n  const client = new KMSClient({ region, ...(endpoint ? { endpoint } : {}) });\n  const resp = await client.send(new DecryptCommand({\n    KeyId: keyId,\n    CiphertextBlob: Buffer.from(ciphertextB64, 'base64'),\n  }));\n  if (!resp.Plaintext) throw new Error(`KMS Decrypt returned an empty Plaintext for key ${keyId}`);\n  const buf = Buffer.from(resp.Plaintext);\n  if (buf.length !== 32) throw new Error(`KMS Decrypt returned ${buf.length}-byte key for ${keyId}; expected 32`);\n  return buf;\n}\n\nexport class KmsKeyProvider implements KeyProvider {\n  private masterKeyCache: Buffer | null = null;\n  private readonly keyId: string;\n  private readonly ciphertextB64: string;\n  private readonly region?: string;\n  private readonly endpoint?: string;\n  private decryptInFlight: Promise<Buffer> | null = null;\n\n  constructor(opts?: { keyId?: string; ciphertextBase64?: string; region?: string; endpoint?: string }) {\n    const keyId = opts?.keyId ?? process.env.SECRET_ENCRYPTION_KMS_KEY_ID;\n    const ciphertext = opts?.ciphertextBase64 ?? process.env.SECRET_ENCRYPTION_KMS_CIPHERTEXT;\n    if (!keyId) throw new Error('SECRET_ENCRYPTION_KMS_KEY_ID env is required for KmsKeyProvider');\n    if (!ciphertext) throw new Error('SECRET_ENCRYPTION_KMS_CIPHERTEXT env is required for KmsKeyProvider');\n    this.keyId = keyId;\n    this.ciphertextB64 = ciphertext;\n    this.region = opts?.region ?? process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION;\n    this.endpoint = opts?.endpoint ?? process.env.AWS_KMS_ENDPOINT;\n  }\n\n  deriveKey(orgId: string): Buffer {\n    if (!this.masterKeyCache) {\n      throw new Error( 'KmsKeyProvider is not warmed up. Call `await provider.warmup()` once at service startup before any encrypt/decrypt.',\n      );\n    }\n    const derived = hkdfSync('sha256', this.masterKeyCache, Buffer.from(orgId, 'utf8'), 'secrets-v1', 32);\n    return Buffer.from(derived);\n  }\n\n  /**\n   * Eagerly recover the master key from KMS so subsequent `deriveKey`\n   * calls are sync. Idempotent  concurrent callers share the same in-\n   * flight promise so we don't spawn multiple KMS Decrypt requests at\n   * boot. Throws on any KMS failure; the caller (typically the service's\n   * onBeforeStart hook) decides whether to fall back to a different\n   * provider or fail-startup.\n   */\n  async warmup(): Promise<void> {\n    if (this.masterKeyCache) return;\n    if (!this.decryptInFlight) {\n      this.decryptInFlight = this.fetchAndDecrypt();\n    }\n    try {\n      this.masterKeyCache = await this.decryptInFlight;\n    } catch (err) {\n      // A transient KMS failure must not permanently poison the provider: clear\n      // the rejected in-flight promise so a later warmup() retries instead of\n      // re-awaiting the same rejection forever (matches PerOrgKmsKeyProvider).\n      this.decryptInFlight = null;\n      throw err;\n    }\n  }\n\n  private fetchAndDecrypt(): Promise<Buffer> {\n    return kmsDecrypt32(this.keyId, this.ciphertextB64, this.region, this.endpoint);\n  }\n}\n\n// Lazy singleton  operator code in long-lived services pays the env-parse\n// cost once, and tests can mint their own provider with a literal key.\nlet defaultProvider: KeyProvider | null = null;\nfunction getDefaultProvider(): KeyProvider {\n  if (!defaultProvider) defaultProvider = new EnvKeyProvider();\n  return defaultProvider;\n}\n\n/** Read the active default provider. Exposed so service code (e.g. an\n *  admin endpoint that just rotated an org's KMS config) can call\n *  `provider.evict(orgId)` on the live provider rather than reconstructing\n *  one. Triggers lazy initialization on first access, same as the internal\n *  callers below. */\nexport function getDefaultKeyProvider(): KeyProvider {\n  return getDefaultProvider();\n}\n\n/**\n * Rotation fallback: an `EnvKeyProvider` over `SECRET_ENCRYPTION_KEY_PREVIOUS`,\n * or null when that env is unset. `undefined` = not yet resolved. While a\n * master-key rotation is in progress, `decryptSecret` retries a failed decrypt\n * under this key, so rows written under the old master stay readable until the\n * re-encryption tool (platform `scripts/reencrypt-secrets.js`) has rewritten\n * them under the new one. Encryption NEVER uses it.\n */\nlet previousProvider: KeyProvider | null | undefined;\nfunction getPreviousProvider(): KeyProvider | null {\n  if (previousProvider === undefined) {\n    const raw = process.env.SECRET_ENCRYPTION_KEY_PREVIOUS;\n    previousProvider = raw ? new EnvKeyProvider(raw) : null;\n  }\n  return previousProvider;\n}\n\n/** Read the rotation-fallback provider (null outside a master-key rotation). */\nexport function getPreviousKeyProvider(): KeyProvider | null {\n  return getPreviousProvider();\n}\n\n/** Reset the cached default (and previous) provider  for tests that mutate `process.env`. */\nexport function resetDefaultKeyProvider(): void { defaultProvider = null; previousProvider = undefined; }\n\n/** Replace the default provider  services that opt into KMS call this\n * once at startup with a warmed-up `KmsKeyProvider`. */\nexport function setKeyProvider(provider: KeyProvider): void { defaultProvider = provider; }\n\n/** Per-org KMS config the operator supplies. The `keyId` identifies the\n *  KMS CMK to call Decrypt on; `ciphertextBase64` is the wrapped 32-byte\n *  master generated by `aws kms encrypt` against that key. */\nexport interface PerOrgKmsConfig {\n  keyId: string;\n  ciphertextBase64: string;\n}\n\n/**\n * Async resolver that maps an org id to its KMS config. Returns `null` when\n * the org has no per-org config — the provider then falls back to the\n * `fallback` provider supplied at construction (usually an EnvKeyProvider\n * or a default KmsKeyProvider).\n */\nexport type PerOrgKmsResolver = (orgId: string) => Promise<PerOrgKmsConfig | null>;\n\n/**\n * Per-org KMS-backed KeyProvider. The blast radius of a KMS key compromise\n * is one org instead of every org under a shared master.\n *\n * Each org has its own KMS CMK + its own wrapped master (stored in Mongo\n * via the operator's setup script). On first encrypt/decrypt for an org,\n * the provider:\n *   1. Calls the resolver to fetch the org's KMS config.\n *   2. Calls `kms:Decrypt` to recover the 32-byte master.\n *   3. Caches the recovered master in-memory for the process lifetime.\n *   4. HKDF-derives per-call from that master + the org id salt.\n *\n * Blobs encrypted by this provider carry `kid = <kms-key-id>` so the\n * decrypt path detects a stale config (operator rotated the key but\n * existing rows weren't re-encrypted) BEFORE AES-GCM throws an opaque\n * authentication-tag error.\n *\n * Orgs without per-org config fall through to the `fallback` provider —\n * mixed-mode deployments where some orgs have KMS isolation and others\n * stay on the shared master are explicitly supported.\n */\nexport class PerOrgKmsKeyProvider implements KeyProvider {\n  /** Cached per-org master keys, keyed by orgId. */\n  private readonly masters = new Map<string, { key: Buffer; kid: string }>();\n  /** Resolved per-org configs cached for the process lifetime. */\n  private readonly configs = new Map<string, PerOrgKmsConfig>();\n  /** In-flight resolver promises so concurrent first-touch callers share one KMS Decrypt.\n   *  Resolves to `null` for orgs with no per-org config — caller treats null as\n   *  \"fall through to the fallback provider\", same as a cold cache miss. */\n  private readonly inFlight = new Map<string, Promise<{ key: Buffer; kid: string } | null>>();\n  /** Orgs the resolver has PROVEN have no per-org config — the fallback provider\n   *  is the correct answer for these, and `deriveKey` may serve them\n   *  synchronously. Distinct from \"not yet resolved\", which must not guess. */\n  private readonly resolvedNoPerOrgConfig = new Set<string>();\n  /** Provider used for orgs that have no per-org config. */\n  private readonly fallback: KeyProvider;\n  private readonly resolver: PerOrgKmsResolver;\n  private readonly region?: string;\n  private readonly endpoint?: string;\n\n  constructor(opts: {\n    resolver: PerOrgKmsResolver;\n    fallback: KeyProvider;\n    region?: string;\n    endpoint?: string;\n  }) {\n    this.resolver = opts.resolver;\n    this.fallback = opts.fallback;\n    this.region = opts.region ?? process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION;\n    this.endpoint = opts.endpoint ?? process.env.AWS_KMS_ENDPOINT;\n  }\n\n  /**\n   * Sync derive. Only correct for an org whose config has already been\n   * RESOLVED — either it has a per-org master (use it) or it provably has no\n   * per-org config (the fallback is then the right answer).\n   *\n   * For an UNRESOLVED org this THROWS rather than guessing. It used to fall\n   * through to the fallback, which silently encrypted that org's secrets under\n   * the SHARED master and — because `kidFor` also returned undefined, so the\n   * both-kids-present mismatch guard could never fire — left them permanently\n   * undecryptable once the org warmed: `decipher.final()` then threw an opaque\n   * auth-tag error with no diagnostic. Failing loud here matches\n   * `KmsKeyProvider.deriveKey`, which has always refused to work cold.\n   *\n   * `encryptSecret`/`decryptSecret` are async and await `deriveKeyAsync`, so\n   * they resolve the org first and never hit this path; it is the backstop for\n   * a caller that reaches for the sync API directly.\n   */\n  deriveKey(orgId: string): Buffer {\n    const cached = this.masters.get(orgId);\n    if (!cached) {\n      if (this.resolvedNoPerOrgConfig.has(orgId)) return this.fallback.deriveKey(orgId);\n      throw new Error( `PerOrgKmsKeyProvider has not resolved org ${orgId}. `\n        + 'Call `await provider.ensureWarmed(orgId)` (or use the async encryptSecret/decryptSecret) '\n        + 'before deriving a key — guessing the shared master would write secrets that cannot be decrypted later.',\n      );\n    }\n    const derived = hkdfSync('sha256', cached.key, Buffer.from(orgId, 'utf8'), 'secrets-v1', 32);\n    return Buffer.from(derived);\n  }\n\n  async deriveKeyAsync(orgId: string): Promise<Buffer> {\n    await this.ensureWarmed(orgId);\n    return this.deriveKey(orgId);\n  }\n\n  kidFor(orgId: string): string | undefined {\n    const cached = this.masters.get(orgId);\n    if (cached) return cached.kid;\n    // Only speak for an org whose config is resolved; an unresolved org has no\n    // meaningful kid, and claiming one would defeat the mismatch guard.\n    if (this.resolvedNoPerOrgConfig.has(orgId)) return this.fallback.kidFor?.(orgId);\n    return undefined;\n  }\n\n  /**\n   * Resolve the org's KMS config, call Decrypt, cache the master. Subsequent\n   * calls for the same org are no-ops. Concurrent callers share the in-flight\n   * Decrypt promise.\n   *\n   * Returns silently when the org has no per-org config — the fallback\n   * provider handles those orgs.\n   */\n  async ensureWarmed(orgId: string): Promise<void> {\n    if (this.masters.has(orgId)) return;\n    // Install the in-flight promise SYNCHRONOUSLY before yielding so concurrent\n    // callers find it on the second-and-later passes. Awaiting the resolver\n    // before populating the map is the bug that lets a Promise.all of 3\n    // callers fire 3 KMS Decrypts.\n    let promise = this.inFlight.get(orgId);\n    if (!promise) {\n      promise = this.resolveAndDecrypt(orgId);\n      this.inFlight.set(orgId, promise);\n      void promise.finally(() => { if (this.inFlight.get(orgId) === promise) this.inFlight.delete(orgId); });\n    }\n    const result = await promise;\n    if (result) this.masters.set(orgId, result);\n    // Remember the NEGATIVE outcome too, so the sync `deriveKey` can tell\n    // \"no per-org config, fallback is correct\" from \"not resolved yet\".\n    else this.resolvedNoPerOrgConfig.add(orgId);\n  }\n\n  private async resolveAndDecrypt(orgId: string): Promise<{ key: Buffer; kid: string } | null> {\n    let cfg = this.configs.get(orgId);\n    if (!cfg) {\n      const resolved = await this.resolver(orgId);\n      if (!resolved) return null; // no per-org config → caller uses fallback\n      cfg = resolved;\n      this.configs.set(orgId, cfg);\n    }\n    const key = await this.fetchAndDecrypt(cfg);\n    return { key, kid: cfg.keyId };\n  }\n\n  private fetchAndDecrypt(cfg: PerOrgKmsConfig): Promise<Buffer> {\n    return kmsDecrypt32(cfg.keyId, cfg.ciphertextBase64, this.region, this.endpoint);\n  }\n\n  /** Evict a cached per-org master. Use after a key rotation so the next\n   *  touch re-fetches the new wrapped master from the resolver. */\n  evict(orgId: string): void {\n    this.masters.delete(orgId);\n    this.configs.delete(orgId);\n    // Also forget a NEGATIVE resolution, or an org that gains a per-org config\n    // after being resolved as \"no config\" would keep using the shared master.\n    this.resolvedNoPerOrgConfig.delete(orgId);\n  }\n}\n\n/**\n * Derive the key for `orgId`, giving the provider a chance to do I/O first.\n *\n * This is why `encryptSecret`/`decryptSecret` are async: `PerOrgKmsKeyProvider`\n * needs one KMS Decrypt the first time it sees an org, and deriving\n * synchronously before that resolves would silently fall back to the shared\n * master and produce secrets that cannot be decrypted afterwards.\n */\nasync function deriveKeyFor(provider: KeyProvider, orgId: string): Promise<Buffer> {\n  return provider.deriveKeyAsync ? provider.deriveKeyAsync(orgId) : provider.deriveKey(orgId);\n}\n\n/**\n * Encrypt a plaintext string for storage. Returns an `EncryptedBlob` that\n * can be JSON-serialized into the underlying column / Mongo document.\n *\n * Empty strings round-trip as `null` so the calling model layer can treat\n * \"no secret set\" identically to \"field absent\".\n */\nexport async function encryptSecret( plaintext: string,\n  orgId: string,\n  provider: KeyProvider = getDefaultProvider(),\n): Promise<EncryptedBlob> {\n  if (!plaintext) {\n    throw new Error('Refusing to encrypt empty string; caller should store null instead');\n  }\n  // Resolve (and warm) the org BEFORE reading `kidFor` below, so a per-org KMS\n  // blob is always stamped with the key it was actually encrypted under.\n  const key = await deriveKeyFor(provider, orgId);\n  const iv = randomBytes(12);\n  const cipher = createCipheriv('aes-256-gcm', key, iv);\n  const enc = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);\n  const tag = cipher.getAuthTag();\n  // PerOrgKmsKeyProvider tags blobs with the KMS key id used so the\n  // decrypt path can refuse to operate if the operator later swaps in a\n  // different per-org config (a misconfigured swap shouldn't silently\n  // accept a stale blob it can't verify against the right CMK).\n  const kid = provider.kidFor?.(orgId);\n  return {\n    alg: 'aes-256-gcm-v1',\n    iv: iv.toString('base64'),\n    // GCM tag MUST travel with the ciphertext or `decryptSecret` can't\n    // verify integrity  concatenate so the on-disk shape is one field.\n    ciphertext: Buffer.concat([enc, tag]).toString('base64'),\n    ...(kid !== undefined ? { kid } : {}),\n  };\n}\n\n/**\n * Decrypt an `EncryptedBlob` written by `encryptSecret`. Throws on * - unknown `alg` (forces an explicit migration when the format changes)\n * - wrong orgId (HKDF binding mismatch fails the auth tag)\n * - tampered ciphertext (GCM auth tag check fails)\n *\n * Callers handle the throw  masking the failure as `null` would hide\n * silent corruption / wrong-org reads.\n *\n * `previous` (default: `SECRET_ENCRYPTION_KEY_PREVIOUS`, when set) is tried\n * only after the primary key fails, and only for kid-less blobs.\n */\nexport async function decryptSecret( blob: EncryptedBlob,\n  orgId: string,\n  provider: KeyProvider = getDefaultProvider(),\n  previous: KeyProvider | null = getPreviousProvider(),\n): Promise<string> {\n  if (blob.alg !== 'aes-256-gcm-v1') {\n    throw new Error(`Unsupported encryption alg: ${blob.alg}`);\n  }\n  // Warm first: `kidFor` and `deriveKey` below must both speak for the org's\n  // real config, or the mismatch guard silently no-ops.\n  const key = await deriveKeyFor(provider, orgId);\n  // If both the provider AND the blob report a kid, they must match.\n  // Mismatch usually means an operator rotated/replaced an org's KMS\n  // config and is now reading a blob encrypted under the OLD key —\n  // failing loud here beats letting AES-GCM throw an opaque auth-tag error.\n  const providerKid = provider.kidFor?.(orgId);\n  if (providerKid !== undefined && blob.kid !== undefined && providerKid !== blob.kid) {\n    throw new Error(`KMS key id mismatch: blob was encrypted under ${blob.kid}, current provider uses ${providerKid} for org ${orgId}`);\n  }\n  try {\n    return decryptWithKey(blob, key);\n  } catch (err) {\n    // Master-key rotation window: retry under SECRET_ENCRYPTION_KEY_PREVIOUS.\n    // Only for a kid-less blob (the env-keyed shape) — a per-org KMS blob is\n    // bound to its CMK and the shared previous master can never open it. The\n    // ORIGINAL error surfaces when the previous key fails too, so a tampered or\n    // wrong-org blob still fails loud exactly as before.\n    if (previous && blob.kid === undefined) {\n      try {\n        return decryptWithKey(blob, await deriveKeyFor(previous, orgId));\n      } catch { /* fall through to the primary error */ }\n    }\n    throw err;\n  }\n}\n\n/** AES-256-GCM open of a blob under one derived key. Throws on any auth-tag failure. */\nfunction decryptWithKey(blob: EncryptedBlob, key: Buffer): string {\n  const iv = Buffer.from(blob.iv, 'base64');\n  const all = Buffer.from(blob.ciphertext, 'base64');\n  // Split off the 16-byte auth tag appended in encryptSecret. Any tampering\n  //  to either the ciphertext OR the tag  causes the next `final()` to\n  // throw with \"Unsupported state or unable to authenticate data\".\n  const tag = all.subarray(all.length - 16);\n  const enc = all.subarray(0, all.length - 16);\n  const decipher = createDecipheriv('aes-256-gcm', key, iv);\n  decipher.setAuthTag(tag);\n  const dec = Buffer.concat([decipher.update(enc), decipher.final()]);\n  return dec.toString('utf8');\n}\n\n/**\n * Type guard  handy for model layers that hold a column whose value may be\n * either a clear-text string (legacy / unencrypted) OR an encrypted blob\n * (post-migration). Mixed states arise mid-migration; the model decides\n * what to do (decrypt on read, encrypt on next write).\n */\nexport function isEncryptedBlob(value: unknown): value is EncryptedBlob {\n  return ( typeof value === 'object'\n    && value !== null\n    && (value as { alg?: unknown }).alg === 'aes-256-gcm-v1'\n    && typeof (value as { iv?: unknown }).iv === 'string'\n    && typeof (value as { ciphertext?: unknown }).ciphertext === 'string'\n  );\n}\n"]}

package/lib/utils/secret-rotation.d.ts

@@ -0,0 +1,17 @@
+/** Gauge name exported by api-server and platform. */
+export declare const SECRET_ROTATION_PREVIOUS_GAUGE = "secret_rotation_previous_set";
+/** True when an env var holds a non-empty value (an empty `KEY=` in .env is unset). */
+export declare function isEnvSet(name: string): boolean;
+/**
+ * Register (or replace) the probe for `secret` — the base name, e.g.
+ * `SECRET_ENCRYPTION_KEY`, or `TOKEN_SIGNING_KEY` for a credential whose overlap
+ * is not an env value at all (there, the probe asks the signer whether a
+ * retiring key is still published). The probe is evaluated at every metrics
+ * scrape, so it must be cheap and must not throw.
+ */
+export declare function registerPreviousSecretProbe(secret: string, isPreviousSet: () => boolean): void;
+/** Current state of every registered probe; a throwing probe reports `false`. */
+export declare function previousSecretStates(): Array<{
+    secret: string;
+    previousSet: boolean;
+}>;