@pipeline-builder/api-core 4.1.2 → 4.1.4

package/lib/middleware/step-up.js

@@ -1,48 +1,59 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-import { buildJwtVerifyOptions, verifyJwtWithRotation, isServicePrincipal } from './auth.js';
-import { createEnvRedisClient } from '../services/env-redis.js';
+import { verifyUserJwt, isServiceAccountPrincipal, isServicePrincipal } from './auth.js';
+import { tagRouteGate } from './route-table.js';
+import { createEnvRedisClient, createRedisReadyGate } from '../services/env-redis.js';
 import { getHeaderString } from '../utils/headers.js';
 import { createLogger } from '../utils/logger.js';
 import { sendError } from '../utils/response.js';
 const logger = createLogger('step-up');
 const HEADER = 'x-step-up-token';
 /**
- * Verify a step-up token: valid signature (primary `JWT_SECRET`, or
- * `JWT_SECRET_PREVIOUS` during a rotation), allow-listed algorithm, issuer and
- * audience when configured, AND the `type: 'step-up'` + `jti` claims — a plain
- * access token shares the secret and `sub`, so without asserting the step-up
- * shape it would bypass the gate. Throws on any failure. Does NOT bind to a
- * caller — `requireStepUp` does the `sub` match and single-use consume.
+ * The factors that count as a SECOND FACTOR, for routes that may only be
+ * unlocked by one (#8: impersonation, KMS, IdP settings, platform admin).
  *
- * Delegates to `requireAuth`'s own primitives rather than re-implementing them.
- * The hand-rolled copy this replaced dropped TWO of their guards: it never
- * pinned issuer/audience (so a step-up token from any other system sharing
- * `JWT_SECRET` was accepted wherever `JWT_ISSUER`/`JWT_AUDIENCE` are set), and
- * its previous-secret retry had no expiry/not-before carve-out, so an EXPIRED
- * token was retried and surfaced as a signature error instead of an expiry one.
+ * A password or a provider re-auth proves the same single factor the session was
+ * already opened with, so on those routes they are not enough: the point is that
+ * someone holding only a stolen session — or only a stolen password — cannot
+ * proceed.
  */
-export function verifyStepUpToken(token) {
-    if (!process.env.JWT_SECRET)
-        throw new Error('JWT_SECRET environment variable is required');
-    const payload = verifyJwtWithRotation(token, buildJwtVerifyOptions());
+export const STRONG_STEP_UP_METHODS = ['webauthn', 'totp'];
+/**
+ * Verify a step-up token: a valid ES256 signature from one of platform's
+ * published signing keys, issuer and audience when configured, AND the
+ * `type: 'step-up'` + `jti` claims — a plain access token is signed by the same
+ * key and carries the same `sub`, so without asserting the step-up shape it
+ * would bypass the gate. Throws on any failure (an unfetchable key set included:
+ * an unverifiable token is not a step-up). Does NOT bind to a caller —
+ * `requireStepUp` does the `sub` match and single-use consume.
+ *
+ * Delegates to `requireAuth`'s own primitive (`verifyUserJwt`) rather than
+ * re-implementing it. The hand-rolled copy this replaced dropped TWO of its
+ * guards: it never pinned issuer/audience, and its previous-secret retry had no
+ * expiry/not-before carve-out, so an EXPIRED token surfaced as a signature error.
+ */
+export async function verifyStepUpToken(token) {
+    const payload = await verifyUserJwt(token);
     if (payload.type !== 'step-up' || !payload.jti || !payload.sub) {
         throw new Error('INVALID_STEP_UP_TOKEN');
     }
     return payload;
 }
-// -- Single-use jti store -----------------------------------------------------
-// Redis SET NX EX when Redis is configured (cross-instance single-use); else a
-// bounded process-local map with TTL sweep (per-process). A step-up token is
-// 60s-lived. When Redis IS configured it's the authoritative store: a Redis
-// error FAILS CLOSED (throws → STEP_UP_INVALID, user re-verifies) rather than
-// degrading to the per-instance mem guard, which would accept a cross-instance
-// replay during the outage. The mem guard is used ONLY when Redis is absent.
 let _redis;
-function redis() {
+let _redisReady;
+/**
+ * The jti client, built lazily. The env client has no offline queue, so a SET on
+ * a connection that isn't up yet is rejected — which used to fail the FIRST
+ * step-up on every pod. Wait (bounded, never rejecting) for readiness before
+ * handing it out; a genuinely down Redis still fails closed on the SET below.
+ */
+async function redis() {
     if (_redis === undefined) {
         _redis = createEnvRedisClient('step-up-jti');
+        _redisReady = _redis ? createRedisReadyGate(_redis) : undefined;
     }
+    if (_redisReady)
+        await _redisReady();
     return _redis;
 }
 const memJti = new Map(); // jti -> expiry epoch ms
@@ -80,7 +91,7 @@ function evictOldestJti() {
  */
 export async function consumeStepUpJti(jti, expEpochSeconds) {
     const ttlSeconds = Math.max(1, expEpochSeconds - Math.floor(Date.now() / 1000));
-    const client = redis();
+    const client = await redis();
     if (client) {
         // Redis configured ⇒ authoritative cross-instance store. SET NX EX → 'OK'
         // when newly set, null when already consumed. A thrown Redis error is NOT
@@ -96,23 +107,43 @@ export async function consumeStepUpJti(jti, expEpochSeconds) {
     memJti.set(jti, Date.now() + ttlSeconds * 1000);
     return true;
 }
-/**
- * Express middleware: require a valid, caller-bound, single-use step-up token in
- * the `X-Step-Up-Token` header. Must run AFTER `requireAuth` (needs `req.user`).
- */
-export async function requireStepUp(req, res, next) {
+export function requireStepUp(reqOrOptions, res, next) {
+    // The direct form RETURNS the promise (Express ignores it; a test awaits it),
+    // so composing the gate as `router.post('/x', requireStepUp, h)` behaves
+    // exactly as it did before the options form existed.
+    if (res && next && 'headers' in reqOrOptions) {
+        return _requireStepUp({}, reqOrOptions, res, next);
+    }
+    const options = reqOrOptions;
+    return tagRouteGate((reqInner, resInner, nextInner) => {
+        void _requireStepUp(options, reqInner, resInner, nextInner);
+    }, { kind: 'stepUp', ...(options.methods ? { methods: [...options.methods] } : {}) });
+}
+tagRouteGate(requireStepUp, { kind: 'stepUp' });
+async function _requireStepUp(options, req, res, next) {
     // Verified internal service principals are EXEMPT: step-up is a re-verify-the-
     // HUMAN gate (they replay a password-reverify token), which a service token
     // structurally cannot produce. Services already bypass `requirePermission` on
     // the same trust basis (a signed service JWT), and internal callers of a
     // step-up-gated route — e.g. the platform org-cascade's `DELETE /quotas/:orgId`
     // or the billing→quota entitlement sync — would otherwise be hard-blocked.
-    // Safe: a service token can only be minted with `JWT_SECRET`, so this can't be
-    // spoofed by an external client to skip step-up.
+    // Safe: a service token can only be minted with a SERVICE's own ES256 key
+    // (#14), which no external client holds, so this can't be spoofed to skip
+    // step-up.
     if (isServicePrincipal(req)) {
         next();
         return;
     }
+    // An ORG SERVICE ACCOUNT is the opposite case: it is subject to every gate a
+    // member is, and there is no person behind it to re-verify — so it can NEVER
+    // pass step-up. Refuse explicitly (rather than letting it fall through to the
+    // `sub`-bound token check, which would fail with a confusing STEP_UP_MISMATCH)
+    // so "a machine credential never satisfies an assurance requirement" is a
+    // property of this gate, not a side effect of how step-up tokens are minted.
+    if (isServiceAccountPrincipal(req)) {
+        sendError(res, 403, 'A service account cannot perform this action — it requires a person to re-verify', 'STEP_UP_NOT_AVAILABLE');
+        return;
+    }
     const callerSub = req.user?.sub;
     if (!callerSub) {
         sendError(res, 401, 'Authentication required', 'UNAUTHORIZED');
@@ -125,7 +156,7 @@ export async function requireStepUp(req, res, next) {
     }
     let payload;
     try {
-        payload = verifyStepUpToken(token);
+        payload = await verifyStepUpToken(token);
     }
     catch {
         sendError(res, 401, 'Step-up token invalid or expired', 'STEP_UP_INVALID');
@@ -135,6 +166,13 @@ export async function requireStepUp(req, res, next) {
         sendError(res, 401, 'Step-up token does not match session', 'STEP_UP_MISMATCH');
         return;
     }
+    // Factor restriction (#8). Checked BEFORE the jti is consumed, so a token
+    // earned by the wrong factor can still be spent on a route that accepts it —
+    // burning it here would make the refusal destructive as well as confusing.
+    if (options.methods && !(payload.method && options.methods.includes(payload.method))) {
+        sendError(res, 401, 'This action must be confirmed with a passkey or an authenticator code', 'STEP_UP_METHOD_REQUIRED', { methods: [...options.methods] });
+        return;
+    }
     try {
         if (!(await consumeStepUpJti(payload.jti, payload.exp))) {
             sendError(res, 401, 'Step-up token already used or expired', 'STEP_UP_REPLAY');
@@ -148,4 +186,4 @@ export async function requireStepUp(req, res, next) {
     }
     next();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-up.js","sourceRoot":"","sources":["../../src/middleware/step-up.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * `requireStepUp` — a shared step-up (recent-password-reverify) gate for the\n * stateless api services, mirroring the platform middleware of the same name.\n *\n * Flow: the UI hits `POST /api/auth/step-up` (platform) to re-verify the user's\n * password; platform mints a short-lived (60s) `step-up` JWT signed with the\n * SAME `JWT_SECRET` these services already verify access tokens with. The UI\n * replays it as the `X-Step-Up-Token` header on the destructive/sensitive call;\n * this middleware verifies it, binds it to the caller (`sub` match), and\n * consumes its `jti` once (Redis-backed cross-instance when configured, else a\n * bounded process-local set) so a replay inside the TTL is rejected.\n *\n * WHY here: restore endpoints on the api services (pipeline/plugin/...) are\n * step-up-gated, but step-up previously lived only in `platform`. This ports the\n * verify + single-use jti into api-core so any service can require it.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport { buildJwtVerifyOptions, verifyJwtWithRotation, isServicePrincipal } from './auth.js';\nimport { createEnvRedisClient } from '../services/env-redis.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { createLogger } from '../utils/logger.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('step-up');\nconst HEADER = 'x-step-up-token';\n\n/** Payload of a platform-issued step-up token (see platform issueStepUpToken). */\nexport interface StepUpTokenPayload {\n  type: 'step-up';\n  sub: string;\n  jti: string;\n  iat: number;\n  exp: number;\n}\n\n/**\n * Verify a step-up token: valid signature (primary `JWT_SECRET`, or\n * `JWT_SECRET_PREVIOUS` during a rotation), allow-listed algorithm, issuer and\n * audience when configured, AND the `type: 'step-up'` + `jti` claims — a plain\n * access token shares the secret and `sub`, so without asserting the step-up\n * shape it would bypass the gate. Throws on any failure. Does NOT bind to a\n * caller — `requireStepUp` does the `sub` match and single-use consume.\n *\n * Delegates to `requireAuth`'s own primitives rather than re-implementing them.\n * The hand-rolled copy this replaced dropped TWO of their guards: it never\n * pinned issuer/audience (so a step-up token from any other system sharing\n * `JWT_SECRET` was accepted wherever `JWT_ISSUER`/`JWT_AUDIENCE` are set), and\n * its previous-secret retry had no expiry/not-before carve-out, so an EXPIRED\n * token was retried and surfaced as a signature error instead of an expiry one.\n */\nexport function verifyStepUpToken(token: string): StepUpTokenPayload {\n  if (!process.env.JWT_SECRET) throw new Error('JWT_SECRET environment variable is required');\n  const payload = verifyJwtWithRotation(token, buildJwtVerifyOptions()) as unknown as StepUpTokenPayload;\n\n  if (payload.type !== 'step-up' || !payload.jti || !payload.sub) {\n    throw new Error('INVALID_STEP_UP_TOKEN');\n  }\n  return payload;\n}\n\n// -- Single-use jti store -----------------------------------------------------\n// Redis SET NX EX when Redis is configured (cross-instance single-use); else a\n// bounded process-local map with TTL sweep (per-process). A step-up token is\n// 60s-lived. When Redis IS configured it's the authoritative store: a Redis\n// error FAILS CLOSED (throws → STEP_UP_INVALID, user re-verifies) rather than\n// degrading to the per-instance mem guard, which would accept a cross-instance\n// replay during the outage. The mem guard is used ONLY when Redis is absent.\n\nlet _redis: { set: (...args: unknown[]) => Promise<unknown> } | null | undefined;\nfunction redis(): { set: (...args: unknown[]) => Promise<unknown> } | null {\n  if (_redis === undefined) {\n    _redis = createEnvRedisClient<{ set: (...args: unknown[]) => Promise<unknown> }>('step-up-jti');\n  }\n  return _redis;\n}\n\nconst memJti = new Map<string, number>(); // jti -> expiry epoch ms\nconst memSweep = setInterval(() => {\n  const now = Date.now();\n  for (const [jti, exp] of memJti) if (exp <= now) memJti.delete(jti);\n}, 30_000);\nmemSweep.unref?.();\n\n/**\n * Hard ceiling on the process-local jti set.\n *\n * The 30s sweep alone does NOT bound it: entries only leave once their token's\n * TTL has passed, so a burst of step-up traffic (or a flood of distinct forged\n * jtis on a Redis-less deployment) grows the map faster than the sweep drains\n * it. This is a replay guard, so shedding the OLDEST entries is the safe\n * direction: the worst case is that a long-expired jti could be replayed, and\n * expiry is enforced independently by the token's own `exp`.\n */\nconst MEM_JTI_MAX = 10_000;\n\n/** Drop the soonest-to-expire entries until the map is under the ceiling. */\nfunction evictOldestJti(): void {\n  if (memJti.size < MEM_JTI_MAX) return;\n  const byExpiry = [...memJti.entries()].sort((a, b) => a[1] - b[1]);\n  const excess = memJti.size - MEM_JTI_MAX + 1;\n  for (let i = 0; i < excess; i += 1) memJti.delete(byExpiry[i][0]);\n}\n\n/**\n * Consume a step-up `jti` exactly once. Returns true if this call claimed it\n * (first use), false if it was already consumed (replay). `expEpochSeconds` is\n * the token's `exp`, so the marker auto-expires with the token.\n */\nexport async function consumeStepUpJti(jti: string, expEpochSeconds: number): Promise<boolean> {\n  const ttlSeconds = Math.max(1, expEpochSeconds - Math.floor(Date.now() / 1000));\n  const client = redis();\n  if (client) {\n    // Redis configured ⇒ authoritative cross-instance store. SET NX EX → 'OK'\n    // when newly set, null when already consumed. A thrown Redis error is NOT\n    // caught here: it propagates so `requireStepUp` fails closed (STEP_UP_INVALID)\n    // instead of silently degrading to the per-instance mem guard.\n    const res = await client.set(`stepup:jti:${jti}`, '1', 'EX', ttlSeconds, 'NX');\n    return res === 'OK';\n  }\n  // No Redis ⇒ single-instance deployment; the process-local map IS the store.\n  if (memJti.has(jti)) return false;\n  evictOldestJti();\n  memJti.set(jti, Date.now() + ttlSeconds * 1000);\n  return true;\n}\n\n/**\n * Express middleware: require a valid, caller-bound, single-use step-up token in\n * the `X-Step-Up-Token` header. Must run AFTER `requireAuth` (needs `req.user`).\n */\nexport async function requireStepUp(req: Request, res: Response, next: NextFunction): Promise<void> {\n  // Verified internal service principals are EXEMPT: step-up is a re-verify-the-\n  // HUMAN gate (they replay a password-reverify token), which a service token\n  // structurally cannot produce. Services already bypass `requirePermission` on\n  // the same trust basis (a signed service JWT), and internal callers of a\n  // step-up-gated route — e.g. the platform org-cascade's `DELETE /quotas/:orgId`\n  // or the billing→quota entitlement sync — would otherwise be hard-blocked.\n  // Safe: a service token can only be minted with `JWT_SECRET`, so this can't be\n  // spoofed by an external client to skip step-up.\n  if (isServicePrincipal(req)) {\n    next();\n    return;\n  }\n\n  const callerSub = (req as Request & { user?: { sub?: string } }).user?.sub;\n  if (!callerSub) {\n    sendError(res, 401, 'Authentication required', 'UNAUTHORIZED');\n    return;\n  }\n\n  const token = getHeaderString(req.headers[HEADER]);\n  if (!token) {\n    sendError(res, 401, 'Step-up verification required', 'STEP_UP_REQUIRED');\n    return;\n  }\n\n  let payload: StepUpTokenPayload;\n  try {\n    payload = verifyStepUpToken(token);\n  } catch {\n    sendError(res, 401, 'Step-up token invalid or expired', 'STEP_UP_INVALID');\n    return;\n  }\n\n  if (payload.sub !== callerSub) {\n    sendError(res, 401, 'Step-up token does not match session', 'STEP_UP_MISMATCH');\n    return;\n  }\n\n  try {\n    if (!(await consumeStepUpJti(payload.jti, payload.exp))) {\n      sendError(res, 401, 'Step-up token already used or expired', 'STEP_UP_REPLAY');\n      return;\n    }\n  } catch (err) {\n    logger.error('Step-up jti consume errored', { error: String(err) });\n    sendError(res, 401, 'Step-up verification failed', 'STEP_UP_INVALID');\n    return;\n  }\n\n  next();\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-up.js","sourceRoot":"","sources":["../../src/middleware/step-up.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAqBtC,OAAO,EAAE,aAAa,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AACzF,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAwB,MAAM,0BAA0B,CAAC;AAC5G,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,MAAM,MAAM,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;AACvC,MAAM,MAAM,GAAG,iBAAiB,CAAC;AASjC;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAA4B,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;AAqBpF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,KAAa;IACnD,MAAM,OAAO,GAAG,MAAM,aAAa,CAAqB,KAAK,CAAC,CAAC;IAE/D,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC;QAC/D,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;IAC3C,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAWD,IAAI,MAAmC,CAAC;AACxC,IAAI,WAA8C,CAAC;AACnD;;;;;GAKG;AACH,KAAK,UAAU,KAAK;IAClB,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,MAAM,GAAG,oBAAoB,CAAW,aAAa,CAAC,CAAC;QACvD,WAAW,GAAG,MAAM,CAAC,CAAC,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAClE,CAAC;IACD,IAAI,WAAW;QAAE,MAAM,WAAW,EAAE,CAAC;IACrC,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC,CAAC,yBAAyB;AACnE,MAAM,QAAQ,GAAG,WAAW,CAAC,GAAG,EAAE;IAChC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACvB,KAAK,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,MAAM;QAAE,IAAI,GAAG,IAAI,GAAG;YAAE,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AACtE,CAAC,EAAE,MAAM,CAAC,CAAC;AACX,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC;AAEnB;;;;;;;;;GASG;AACH,MAAM,WAAW,GAAG,MAAM,CAAC;AAE3B,6EAA6E;AAC7E,SAAS,cAAc;IACrB,IAAI,MAAM,CAAC,IAAI,GAAG,WAAW;QAAE,OAAO;IACtC,MAAM,QAAQ,GAAG,CAAC,GAAG,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACnE,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,GAAG,WAAW,GAAG,CAAC,CAAC;IAC7C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC;QAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACpE,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,GAAW,EAAE,eAAuB;IACzE,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC;IAChF,MAAM,MAAM,GAAG,MAAM,KAAK,EAAE,CAAC;IAC7B,IAAI,MAAM,EAAE,CAAC;QACX,0EAA0E;QAC1E,0EAA0E;QAC1E,+EAA+E;QAC/E,+DAA+D;QAC/D,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,GAAG,CAAC,cAAc,GAAG,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;QAC/E,OAAO,GAAG,KAAK,IAAI,CAAC;IACtB,CAAC;IACD,6EAA6E;IAC7E,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC;QAAE,OAAO,KAAK,CAAC;IAClC,cAAc,EAAE,CAAC;IACjB,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,UAAU,GAAG,IAAI,CAAC,CAAC;IAChD,OAAO,IAAI,CAAC;AACd,CAAC;AAcD,MAAM,UAAU,aAAa,CAC3B,YAA4C,EAC5C,GAAc,EACd,IAAmB;IAEnB,8EAA8E;IAC9E,yEAAyE;IACzE,qDAAqD;IACrD,IAAI,GAAG,IAAI,IAAI,IAAI,SAAS,IAAI,YAAY,EAAE,CAAC;QAC7C,OAAO,cAAc,CAAC,EAAE,EAAE,YAAuB,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;IAChE,CAAC;IACD,MAAM,OAAO,GAAG,YAAoC,CAAC;IACrD,OAAO,YAAY,CACjB,CAAC,QAAiB,EAAE,QAAkB,EAAE,SAAuB,EAAE,EAAE;QACjE,KAAK,cAAc,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;IAC9D,CAAC,EACD,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAClF,CAAC;AACJ,CAAC;AACD,YAAY,CAAC,aAAa,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;AAEhD,KAAK,UAAU,cAAc,CAAC,OAA6B,EAAE,GAAY,EAAE,GAAa,EAAE,IAAkB;IAC1G,+EAA+E;IAC/E,4EAA4E;IAC5E,8EAA8E;IAC9E,yEAAyE;IACzE,gFAAgF;IAChF,2EAA2E;IAC3E,0EAA0E;IAC1E,0EAA0E;IAC1E,WAAW;IACX,IAAI,kBAAkB,CAAC,GAAG,CAAC,EAAE,CAAC;QAC5B,IAAI,EAAE,CAAC;QACP,OAAO;IACT,CAAC;IAED,6EAA6E;IAC7E,6EAA6E;IAC7E,8EAA8E;IAC9E,+EAA+E;IAC/E,0EAA0E;IAC1E,6EAA6E;IAC7E,IAAI,yBAAyB,CAAC,GAAG,CAAC,EAAE,CAAC;QACnC,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,kFAAkF,EAAE,uBAAuB,CAAC,CAAC;QACjI,OAAO;IACT,CAAC;IAED,MAAM,SAAS,GAAI,GAA6C,CAAC,IAAI,EAAE,GAAG,CAAC;IAC3E,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,yBAAyB,EAAE,cAAc,CAAC,CAAC;QAC/D,OAAO;IACT,CAAC;IAED,MAAM,KAAK,GAAG,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;IACnD,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,+BAA+B,EAAE,kBAAkB,CAAC,CAAC;QACzE,OAAO;IACT,CAAC;IAED,IAAI,OAA2B,CAAC;IAChC,IAAI,CAAC;QACH,OAAO,GAAG,MAAM,iBAAiB,CAAC,KAAK,CAAC,CAAC;IAC3C,CAAC;IAAC,MAAM,CAAC;QACP,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,kCAAkC,EAAE,iBAAiB,CAAC,CAAC;QAC3E,OAAO;IACT,CAAC;IAED,IAAI,OAAO,CAAC,GAAG,KAAK,SAAS,EAAE,CAAC;QAC9B,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,sCAAsC,EAAE,kBAAkB,CAAC,CAAC;QAChF,OAAO;IACT,CAAC;IAED,0EAA0E;IAC1E,6EAA6E;IAC7E,2EAA2E;IAC3E,IAAI,OAAO,CAAC,OAAO,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;QACrF,SAAS,CACP,GAAG,EAAE,GAAG,EACR,uEAAuE,EACvE,yBAAyB,EACzB,EAAE,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,EAAE,CAClC,CAAC;QACF,OAAO;IACT,CAAC;IAED,IAAI,CAAC;QACH,IAAI,CAAC,CAAC,MAAM,gBAAgB,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;YACxD,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,uCAAuC,EAAE,gBAAgB,CAAC,CAAC;YAC/E,OAAO;QACT,CAAC;IACH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,KAAK,CAAC,6BAA6B,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACpE,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,6BAA6B,EAAE,iBAAiB,CAAC,CAAC;QACtE,OAAO;IACT,CAAC;IAED,IAAI,EAAE,CAAC;AACT,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * `requireStepUp` — a shared step-up (recent-password-reverify) gate for the\n * stateless api services, mirroring the platform middleware of the same name.\n *\n * Flow: the UI hits `POST /api/auth/step-up` (platform) to re-verify the user;\n * platform mints a short-lived (60s) `step-up` JWT with the SAME ES256 signing\n * key it mints access tokens with, so these services verify it through the same\n * JWKS. The UI\n * replays it as the `X-Step-Up-Token` header on the destructive/sensitive call;\n * this middleware verifies it, binds it to the caller (`sub` match), and\n * consumes its `jti` once (Redis-backed cross-instance when configured, else a\n * bounded process-local set) so a replay inside the TTL is rejected.\n *\n * WHY here: restore endpoints on the api services (pipeline/plugin/...) are\n * step-up-gated, but step-up previously lived only in `platform`. This ports the\n * verify + single-use jti into api-core so any service can require it.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport { verifyUserJwt, isServiceAccountPrincipal, isServicePrincipal } from './auth.js';\nimport { tagRouteGate } from './route-table.js';\nimport { createEnvRedisClient, createRedisReadyGate, type ReadyAwareRedis } from '../services/env-redis.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { createLogger } from '../utils/logger.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('step-up');\nconst HEADER = 'x-step-up-token';\n\n/**\n * How a step-up token was earned. Mirrors platform's `StepUpMethod`; kept here\n * as its own union so a verifier can name the factors it accepts without\n * importing platform.\n */\nexport type StepUpMethod = 'password' | 'webauthn' | 'totp' | 'reauth';\n\n/**\n * The factors that count as a SECOND FACTOR, for routes that may only be\n * unlocked by one (#8: impersonation, KMS, IdP settings, platform admin).\n *\n * A password or a provider re-auth proves the same single factor the session was\n * already opened with, so on those routes they are not enough: the point is that\n * someone holding only a stolen session — or only a stolen password — cannot\n * proceed.\n */\nexport const STRONG_STEP_UP_METHODS: readonly StepUpMethod[] = ['webauthn', 'totp'];\n\n/** Payload of a platform-issued step-up token (see platform issueStepUpToken). */\nexport interface StepUpTokenPayload {\n  type: 'step-up';\n  sub: string;\n  jti: string;\n  /** Which factor earned it. Absent only on a token minted before the claim\n   *  existed, which a method-restricted gate treats as \"not proven\". */\n  method?: StepUpMethod;\n  iat: number;\n  exp: number;\n}\n\n/** Options for {@link requireStepUp}. */\nexport interface RequireStepUpOptions {\n  /** Restrict which factors may earn the step-up (e.g. {@link STRONG_STEP_UP_METHODS}).\n   *  Omitted means any factor the platform will issue a token for. */\n  methods?: readonly StepUpMethod[];\n}\n\n/**\n * Verify a step-up token: a valid ES256 signature from one of platform's\n * published signing keys, issuer and audience when configured, AND the\n * `type: 'step-up'` + `jti` claims — a plain access token is signed by the same\n * key and carries the same `sub`, so without asserting the step-up shape it\n * would bypass the gate. Throws on any failure (an unfetchable key set included:\n * an unverifiable token is not a step-up). Does NOT bind to a caller —\n * `requireStepUp` does the `sub` match and single-use consume.\n *\n * Delegates to `requireAuth`'s own primitive (`verifyUserJwt`) rather than\n * re-implementing it. The hand-rolled copy this replaced dropped TWO of its\n * guards: it never pinned issuer/audience, and its previous-secret retry had no\n * expiry/not-before carve-out, so an EXPIRED token surfaced as a signature error.\n */\nexport async function verifyStepUpToken(token: string): Promise<StepUpTokenPayload> {\n  const payload = await verifyUserJwt<StepUpTokenPayload>(token);\n\n  if (payload.type !== 'step-up' || !payload.jti || !payload.sub) {\n    throw new Error('INVALID_STEP_UP_TOKEN');\n  }\n  return payload;\n}\n\n// -- Single-use jti store -----------------------------------------------------\n// Redis SET NX EX when Redis is configured (cross-instance single-use); else a\n// bounded process-local map with TTL sweep (per-process). A step-up token is\n// 60s-lived. When Redis IS configured it's the authoritative store: a Redis\n// error FAILS CLOSED (throws → STEP_UP_INVALID, user re-verifies) rather than\n// degrading to the per-instance mem guard, which would accept a cross-instance\n// replay during the outage. The mem guard is used ONLY when Redis is absent.\n\ntype JtiRedis = ReadyAwareRedis & { set: (...args: unknown[]) => Promise<unknown> };\nlet _redis: JtiRedis | null | undefined;\nlet _redisReady: (() => Promise<void>) | undefined;\n/**\n * The jti client, built lazily. The env client has no offline queue, so a SET on\n * a connection that isn't up yet is rejected — which used to fail the FIRST\n * step-up on every pod. Wait (bounded, never rejecting) for readiness before\n * handing it out; a genuinely down Redis still fails closed on the SET below.\n */\nasync function redis(): Promise<JtiRedis | null> {\n  if (_redis === undefined) {\n    _redis = createEnvRedisClient<JtiRedis>('step-up-jti');\n    _redisReady = _redis ? createRedisReadyGate(_redis) : undefined;\n  }\n  if (_redisReady) await _redisReady();\n  return _redis;\n}\n\nconst memJti = new Map<string, number>(); // jti -> expiry epoch ms\nconst memSweep = setInterval(() => {\n  const now = Date.now();\n  for (const [jti, exp] of memJti) if (exp <= now) memJti.delete(jti);\n}, 30_000);\nmemSweep.unref?.();\n\n/**\n * Hard ceiling on the process-local jti set.\n *\n * The 30s sweep alone does NOT bound it: entries only leave once their token's\n * TTL has passed, so a burst of step-up traffic (or a flood of distinct forged\n * jtis on a Redis-less deployment) grows the map faster than the sweep drains\n * it. This is a replay guard, so shedding the OLDEST entries is the safe\n * direction: the worst case is that a long-expired jti could be replayed, and\n * expiry is enforced independently by the token's own `exp`.\n */\nconst MEM_JTI_MAX = 10_000;\n\n/** Drop the soonest-to-expire entries until the map is under the ceiling. */\nfunction evictOldestJti(): void {\n  if (memJti.size < MEM_JTI_MAX) return;\n  const byExpiry = [...memJti.entries()].sort((a, b) => a[1] - b[1]);\n  const excess = memJti.size - MEM_JTI_MAX + 1;\n  for (let i = 0; i < excess; i += 1) memJti.delete(byExpiry[i][0]);\n}\n\n/**\n * Consume a step-up `jti` exactly once. Returns true if this call claimed it\n * (first use), false if it was already consumed (replay). `expEpochSeconds` is\n * the token's `exp`, so the marker auto-expires with the token.\n */\nexport async function consumeStepUpJti(jti: string, expEpochSeconds: number): Promise<boolean> {\n  const ttlSeconds = Math.max(1, expEpochSeconds - Math.floor(Date.now() / 1000));\n  const client = await redis();\n  if (client) {\n    // Redis configured ⇒ authoritative cross-instance store. SET NX EX → 'OK'\n    // when newly set, null when already consumed. A thrown Redis error is NOT\n    // caught here: it propagates so `requireStepUp` fails closed (STEP_UP_INVALID)\n    // instead of silently degrading to the per-instance mem guard.\n    const res = await client.set(`stepup:jti:${jti}`, '1', 'EX', ttlSeconds, 'NX');\n    return res === 'OK';\n  }\n  // No Redis ⇒ single-instance deployment; the process-local map IS the store.\n  if (memJti.has(jti)) return false;\n  evictOldestJti();\n  memJti.set(jti, Date.now() + ttlSeconds * 1000);\n  return true;\n}\n\n/**\n * Express middleware: require a valid, caller-bound, single-use step-up token in\n * the `X-Step-Up-Token` header. Must run AFTER `requireAuth` (needs `req.user`).\n *\n * Use directly (`router.post('/x', requireAuth, requireStepUp, h)`) for the\n * ordinary any-factor gate, or call it with `{ methods }` to demand that the\n * confirmation was earned by a specific factor — `requireStepUp({ methods:\n * STRONG_STEP_UP_METHODS })` on the routes where a password re-prompt is not a\n * meaningful second proof.\n */\nexport function requireStepUp(req: Request, res: Response, next: NextFunction): Promise<void>;\nexport function requireStepUp(options: RequireStepUpOptions): (req: Request, res: Response, next: NextFunction) => void;\nexport function requireStepUp(\n  reqOrOptions: Request | RequireStepUpOptions,\n  res?: Response,\n  next?: NextFunction,\n): Promise<void> | ((req: Request, res: Response, next: NextFunction) => void) {\n  // The direct form RETURNS the promise (Express ignores it; a test awaits it),\n  // so composing the gate as `router.post('/x', requireStepUp, h)` behaves\n  // exactly as it did before the options form existed.\n  if (res && next && 'headers' in reqOrOptions) {\n    return _requireStepUp({}, reqOrOptions as Request, res, next);\n  }\n  const options = reqOrOptions as RequireStepUpOptions;\n  return tagRouteGate(\n    (reqInner: Request, resInner: Response, nextInner: NextFunction) => {\n      void _requireStepUp(options, reqInner, resInner, nextInner);\n    },\n    { kind: 'stepUp', ...(options.methods ? { methods: [...options.methods] } : {}) },\n  );\n}\ntagRouteGate(requireStepUp, { kind: 'stepUp' });\n\nasync function _requireStepUp(options: RequireStepUpOptions, req: Request, res: Response, next: NextFunction): Promise<void> {\n  // Verified internal service principals are EXEMPT: step-up is a re-verify-the-\n  // HUMAN gate (they replay a password-reverify token), which a service token\n  // structurally cannot produce. Services already bypass `requirePermission` on\n  // the same trust basis (a signed service JWT), and internal callers of a\n  // step-up-gated route — e.g. the platform org-cascade's `DELETE /quotas/:orgId`\n  // or the billing→quota entitlement sync — would otherwise be hard-blocked.\n  // Safe: a service token can only be minted with a SERVICE's own ES256 key\n  // (#14), which no external client holds, so this can't be spoofed to skip\n  // step-up.\n  if (isServicePrincipal(req)) {\n    next();\n    return;\n  }\n\n  // An ORG SERVICE ACCOUNT is the opposite case: it is subject to every gate a\n  // member is, and there is no person behind it to re-verify — so it can NEVER\n  // pass step-up. Refuse explicitly (rather than letting it fall through to the\n  // `sub`-bound token check, which would fail with a confusing STEP_UP_MISMATCH)\n  // so \"a machine credential never satisfies an assurance requirement\" is a\n  // property of this gate, not a side effect of how step-up tokens are minted.\n  if (isServiceAccountPrincipal(req)) {\n    sendError(res, 403, 'A service account cannot perform this action — it requires a person to re-verify', 'STEP_UP_NOT_AVAILABLE');\n    return;\n  }\n\n  const callerSub = (req as Request & { user?: { sub?: string } }).user?.sub;\n  if (!callerSub) {\n    sendError(res, 401, 'Authentication required', 'UNAUTHORIZED');\n    return;\n  }\n\n  const token = getHeaderString(req.headers[HEADER]);\n  if (!token) {\n    sendError(res, 401, 'Step-up verification required', 'STEP_UP_REQUIRED');\n    return;\n  }\n\n  let payload: StepUpTokenPayload;\n  try {\n    payload = await verifyStepUpToken(token);\n  } catch {\n    sendError(res, 401, 'Step-up token invalid or expired', 'STEP_UP_INVALID');\n    return;\n  }\n\n  if (payload.sub !== callerSub) {\n    sendError(res, 401, 'Step-up token does not match session', 'STEP_UP_MISMATCH');\n    return;\n  }\n\n  // Factor restriction (#8). Checked BEFORE the jti is consumed, so a token\n  // earned by the wrong factor can still be spent on a route that accepts it —\n  // burning it here would make the refusal destructive as well as confusing.\n  if (options.methods && !(payload.method && options.methods.includes(payload.method))) {\n    sendError(\n      res, 401,\n      'This action must be confirmed with a passkey or an authenticator code',\n      'STEP_UP_METHOD_REQUIRED',\n      { methods: [...options.methods] },\n    );\n    return;\n  }\n\n  try {\n    if (!(await consumeStepUpJti(payload.jti, payload.exp))) {\n      sendError(res, 401, 'Step-up token already used or expired', 'STEP_UP_REPLAY');\n      return;\n    }\n  } catch (err) {\n    logger.error('Step-up jti consume errored', { error: String(err) });\n    sendError(res, 401, 'Step-up verification failed', 'STEP_UP_INVALID');\n    return;\n  }\n\n  next();\n}\n"]}

package/lib/services/api-key-exchange.d.ts

@@ -0,0 +1,25 @@
+/** The key was presented to platform and refused (unknown, revoked, expired). */
+export declare class ApiKeyRejectedError extends Error {
+    constructor(message?: string);
+}
+/** Platform could not be reached (or answered 5xx) — the key's validity is unknown. */
+export declare class ApiKeyExchangeUnavailableError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Name this process in the exchange call's service token. Called from
+ * `wireServiceSecurity` at boot (and by the plugin service, which wires its
+ * boot security by hand).
+ */
+export declare function setApiKeyExchangeServiceName(name: string): void;
+/**
+ * The JWT for `key`, from cache when possible. Throws {@link ApiKeyRejectedError}
+ * when platform refused the key and {@link ApiKeyExchangeUnavailableError} when
+ * it could not be asked.
+ */
+export declare function exchangeApiKey(key: string): Promise<string>;
+/**
+ * Drop every cached exchange. For tests and for a process that wants to force
+ * re-validation; production relies on the TTLs above.
+ */
+export declare function resetApiKeyExchangeCache(): void;

package/lib/services/api-key-exchange.js

@@ -0,0 +1,219 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Trade an opaque access key for a short-lived JWT, once, and cache it.
+ *
+ * Only platform, billing and quota have MongoDB, so the stateless services
+ * cannot look up a key hash — and asking platform to validate EVERY request
+ * would put it on the hot path of the whole fleet. Instead this module does the
+ * exchange once per key (`POST /auth/token/exchange`) and caches the returned
+ * JWT in-process until it expires, so `requireAuth` only ever verifies a JWT.
+ *
+ * Properties that matter:
+ *
+ * - **Revocation latency is bounded by the token TTL** (5 minutes). A revoked
+ *   key can no longer be exchanged, and the cached token it already produced
+ *   dies on its own.
+ * - **Early, jittered refresh.** The cached token is re-exchanged in the
+ *   background at ~75% of its life (±20% jitter) so no request ever blocks on
+ *   the exchange, and a fleet of pods holding the same key doesn't stampede
+ *   platform at the same instant.
+ * - **One in-flight exchange per key.** Concurrent requests share a promise.
+ * - **Short negative cache.** A key platform rejected is remembered for 30s, so
+ *   a misconfigured client (or a scanner) can't turn every request into a
+ *   platform round-trip.
+ * - **Platform down is a 503, never a 200.** The caller maps
+ *   {@link ApiKeyExchangeUnavailableError} to "try again", with a metric — it is
+ *   deliberately NOT fail-open: an unverifiable credential is not an identity.
+ *
+ * The exchange request itself carries this service's own signed service token,
+ * which is what exempts it from platform's IP-keyed `/auth` rate limiter (every
+ * pod's exchanges would otherwise share one bucket) and names the caller in
+ * platform's audit trail.
+ */
+import { getServiceAuthHeader, SYSTEM_ORG_ID } from '../middleware/auth.js';
+import { InternalHttpClient } from '../services/http-client.js';
+import { hashApiKey } from '../utils/api-key.js';
+import { createLogger } from '../utils/logger.js';
+import { emitCounter } from '../utils/metric-emitter.js';
+const logger = createLogger('api-key-exchange');
+/** Most distinct keys held in the process-wide cache before the oldest are dropped. */
+const MAX_CACHED_KEYS = 1000;
+/** How long a platform REJECTION is remembered (ms). */
+const NEGATIVE_TTL_MS = 30_000;
+/** Fraction of a token's life after which a background re-exchange is started. */
+const REFRESH_AT_FRACTION = 0.75;
+/** ± jitter applied to the refresh point, as a fraction of the token's life.
+ *  Wide enough to de-synchronize a fleet, narrow enough to leave a clear tail of
+ *  still-valid token after the latest possible refresh. */
+const REFRESH_JITTER_FRACTION = 0.1;
+/** The key was presented to platform and refused (unknown, revoked, expired). */
+export class ApiKeyRejectedError extends Error {
+    constructor(message = 'Access key is invalid, revoked or expired') {
+        super(message);
+        this.name = 'ApiKeyRejectedError';
+    }
+}
+/** Platform could not be reached (or answered 5xx) — the key's validity is unknown. */
+export class ApiKeyExchangeUnavailableError extends Error {
+    constructor(message = 'Access-key verification is temporarily unavailable') {
+        super(message);
+        this.name = 'ApiKeyExchangeUnavailableError';
+    }
+}
+/** Cache of successful exchanges, keyed by `sha256(key)` — never by the key itself. */
+const tokenCache = new Map();
+/** Cache of rejections, keyed the same way; value is the epoch ms it expires. */
+const rejectionCache = new Map();
+/** In-flight exchanges, so concurrent requests for one key share a round-trip. */
+const inFlight = new Map();
+/** The service name minted into the exchange call's own service token. */
+let serviceName = process.env.SERVICE_NAME || 'unknown';
+/**
+ * Name this process in the exchange call's service token. Called from
+ * `wireServiceSecurity` at boot (and by the plugin service, which wires its
+ * boot security by hand).
+ */
+export function setApiKeyExchangeServiceName(name) {
+    serviceName = name;
+}
+/** Platform's in-cluster address — the same env pair every other caller uses. */
+function platformClient() {
+    return new InternalHttpClient({
+        host: process.env.PLATFORM_SERVICE_HOST || 'platform',
+        port: parseInt(process.env.PLATFORM_SERVICE_PORT || '3000', 10),
+        timeout: parseInt(process.env.API_KEY_EXCHANGE_TIMEOUT_MS || '3000', 10),
+    });
+}
+/** The epoch ms at which a token with `ttlSeconds` of life should be refreshed early. */
+function jitteredRefreshAt(issuedAt, ttlSeconds) {
+    const lifeMs = ttlSeconds * 1000;
+    const jitter = (Math.random() * 2 - 1) * REFRESH_JITTER_FRACTION;
+    // Clamp into (0, 1) so the refresh point is always before expiry and never in
+    // the past, whatever TTL platform returns.
+    const fraction = Math.min(0.95, Math.max(0.1, REFRESH_AT_FRACTION + jitter));
+    return issuedAt + lifeMs * fraction;
+}
+/** Drop the oldest entries once the cache is over its cap (keys are long-lived, tokens are not). */
+function evictIfFull() {
+    if (tokenCache.size <= MAX_CACHED_KEYS)
+        return;
+    const now = Date.now();
+    for (const [hash, entry] of tokenCache) {
+        if (entry.expiresAt <= now)
+            tokenCache.delete(hash);
+    }
+    // Map preserves insertion order — drop from the front until back under the cap.
+    while (tokenCache.size > MAX_CACHED_KEYS) {
+        const oldest = tokenCache.keys().next();
+        if (oldest.done)
+            break;
+        tokenCache.delete(oldest.value);
+    }
+}
+/** One real round-trip to platform. Throws the two typed errors above. */
+async function performExchange(key, hash) {
+    const client = platformClient();
+    let status;
+    let body;
+    try {
+        const res = await client.post('/auth/token/exchange', { key }, {
+            headers: {
+                Authorization: getServiceAuthHeader({ serviceName, role: 'member', orgId: SYSTEM_ORG_ID }),
+            },
+            // The exchange is a pure read of the key record plus a token mint — safe to
+            // retry, and a lost retry only costs one extra mint.
+            idempotent: true,
+        });
+        status = res.statusCode;
+        body = res.body;
+    }
+    catch (err) {
+        emitCounter('api_key_exchange_total', { result: 'unavailable' });
+        emitCounter('api_key_exchange_failures_total', { reason: 'unavailable' });
+        logger.warn('Access-key exchange failed to reach platform', {
+            error: err instanceof Error ? err.message : String(err),
+        });
+        throw new ApiKeyExchangeUnavailableError();
+    }
+    if (status === 401 || status === 403 || status === 400 || status === 404) {
+        rejectionCache.set(hash, Date.now() + NEGATIVE_TTL_MS);
+        emitCounter('api_key_exchange_total', { result: 'rejected' });
+        emitCounter('api_key_exchange_failures_total', { reason: 'rejected' });
+        throw new ApiKeyRejectedError();
+    }
+    const accessToken = body?.data?.accessToken;
+    if (status >= 400 || typeof accessToken !== 'string' || accessToken.length === 0) {
+        // 429 and 5xx land here: platform is up but can't answer right now, which is
+        // "unknown", not "invalid" — never cache it as a rejection.
+        emitCounter('api_key_exchange_total', { result: 'unavailable' });
+        emitCounter('api_key_exchange_failures_total', { reason: status === 429 ? 'throttled' : 'server_error' });
+        throw new ApiKeyExchangeUnavailableError();
+    }
+    const ttlSeconds = typeof body?.data?.expiresIn === 'number' && body.data.expiresIn > 0
+        ? body.data.expiresIn
+        : 60;
+    const now = Date.now();
+    const entry = {
+        token: accessToken,
+        expiresAt: now + ttlSeconds * 1000,
+        refreshAt: jitteredRefreshAt(now, ttlSeconds),
+    };
+    tokenCache.set(hash, entry);
+    rejectionCache.delete(hash);
+    evictIfFull();
+    emitCounter('api_key_exchange_total', { result: 'success' });
+    return entry;
+}
+/** Exchange, sharing a single in-flight round-trip per key. */
+function exchangeOnce(key, hash) {
+    const pending = inFlight.get(hash);
+    if (pending)
+        return pending;
+    const promise = performExchange(key, hash).finally(() => inFlight.delete(hash));
+    inFlight.set(hash, promise);
+    return promise;
+}
+/**
+ * The JWT for `key`, from cache when possible. Throws {@link ApiKeyRejectedError}
+ * when platform refused the key and {@link ApiKeyExchangeUnavailableError} when
+ * it could not be asked.
+ */
+export async function exchangeApiKey(key) {
+    const hash = hashApiKey(key);
+    const now = Date.now();
+    const rejectedUntil = rejectionCache.get(hash);
+    if (rejectedUntil !== undefined) {
+        if (rejectedUntil > now) {
+            emitCounter('api_key_exchange_cache_total', { result: 'rejected' });
+            throw new ApiKeyRejectedError();
+        }
+        rejectionCache.delete(hash);
+    }
+    const cached = tokenCache.get(hash);
+    if (cached && cached.expiresAt > now) {
+        if (cached.refreshAt <= now && !inFlight.has(hash)) {
+            // Early refresh: warm the cache WITHOUT making this request wait. A failed
+            // background refresh is not this request's problem — the cached token is
+            // still valid, and the next request past expiry exchanges inline.
+            emitCounter('api_key_exchange_cache_total', { result: 'refresh' });
+            void exchangeOnce(key, hash).catch(() => { });
+        }
+        else {
+            emitCounter('api_key_exchange_cache_total', { result: 'hit' });
+        }
+        return cached.token;
+    }
+    emitCounter('api_key_exchange_cache_total', { result: 'miss' });
+    return (await exchangeOnce(key, hash)).token;
+}
+/**
+ * Drop every cached exchange. For tests and for a process that wants to force
+ * re-validation; production relies on the TTLs above.
+ */
+export function resetApiKeyExchangeCache() {
+    tokenCache.clear();
+    rejectionCache.clear();
+    inFlight.clear();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-key-exchange.js","sourceRoot":"","sources":["../../src/services/api-key-exchange.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Trade an opaque access key for a short-lived JWT, once, and cache it.\n *\n * Only platform, billing and quota have MongoDB, so the stateless services\n * cannot look up a key hash — and asking platform to validate EVERY request\n * would put it on the hot path of the whole fleet. Instead this module does the\n * exchange once per key (`POST /auth/token/exchange`) and caches the returned\n * JWT in-process until it expires, so `requireAuth` only ever verifies a JWT.\n *\n * Properties that matter:\n *\n * - **Revocation latency is bounded by the token TTL** (5 minutes). A revoked\n *   key can no longer be exchanged, and the cached token it already produced\n *   dies on its own.\n * - **Early, jittered refresh.** The cached token is re-exchanged in the\n *   background at ~75% of its life (±20% jitter) so no request ever blocks on\n *   the exchange, and a fleet of pods holding the same key doesn't stampede\n *   platform at the same instant.\n * - **One in-flight exchange per key.** Concurrent requests share a promise.\n * - **Short negative cache.** A key platform rejected is remembered for 30s, so\n *   a misconfigured client (or a scanner) can't turn every request into a\n *   platform round-trip.\n * - **Platform down is a 503, never a 200.** The caller maps\n *   {@link ApiKeyExchangeUnavailableError} to \"try again\", with a metric — it is\n *   deliberately NOT fail-open: an unverifiable credential is not an identity.\n *\n * The exchange request itself carries this service's own signed service token,\n * which is what exempts it from platform's IP-keyed `/auth` rate limiter (every\n * pod's exchanges would otherwise share one bucket) and names the caller in\n * platform's audit trail.\n */\n\nimport { getServiceAuthHeader, SYSTEM_ORG_ID } from '../middleware/auth.js';\nimport { InternalHttpClient } from '../services/http-client.js';\nimport { hashApiKey } from '../utils/api-key.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('api-key-exchange');\n\n/** Most distinct keys held in the process-wide cache before the oldest are dropped. */\nconst MAX_CACHED_KEYS = 1000;\n\n/** How long a platform REJECTION is remembered (ms). */\nconst NEGATIVE_TTL_MS = 30_000;\n\n/** Fraction of a token's life after which a background re-exchange is started. */\nconst REFRESH_AT_FRACTION = 0.75;\n\n/** ± jitter applied to the refresh point, as a fraction of the token's life.\n *  Wide enough to de-synchronize a fleet, narrow enough to leave a clear tail of\n *  still-valid token after the latest possible refresh. */\nconst REFRESH_JITTER_FRACTION = 0.1;\n\n/** The key was presented to platform and refused (unknown, revoked, expired). */\nexport class ApiKeyRejectedError extends Error {\n  constructor(message = 'Access key is invalid, revoked or expired') {\n    super(message);\n    this.name = 'ApiKeyRejectedError';\n  }\n}\n\n/** Platform could not be reached (or answered 5xx) — the key's validity is unknown. */\nexport class ApiKeyExchangeUnavailableError extends Error {\n  constructor(message = 'Access-key verification is temporarily unavailable') {\n    super(message);\n    this.name = 'ApiKeyExchangeUnavailableError';\n  }\n}\n\ninterface CacheEntry {\n  /** The exchanged JWT. */\n  token: string;\n  /** Epoch ms at which the JWT stops being usable. */\n  expiresAt: number;\n  /** Epoch ms after which a background re-exchange should be started. */\n  refreshAt: number;\n}\n\n/** Cache of successful exchanges, keyed by `sha256(key)` — never by the key itself. */\nconst tokenCache = new Map<string, CacheEntry>();\n/** Cache of rejections, keyed the same way; value is the epoch ms it expires. */\nconst rejectionCache = new Map<string, number>();\n/** In-flight exchanges, so concurrent requests for one key share a round-trip. */\nconst inFlight = new Map<string, Promise<CacheEntry>>();\n\n/** The service name minted into the exchange call's own service token. */\nlet serviceName = process.env.SERVICE_NAME || 'unknown';\n\n/**\n * Name this process in the exchange call's service token. Called from\n * `wireServiceSecurity` at boot (and by the plugin service, which wires its\n * boot security by hand).\n */\nexport function setApiKeyExchangeServiceName(name: string): void {\n  serviceName = name;\n}\n\n/** Platform's in-cluster address — the same env pair every other caller uses. */\nfunction platformClient(): InternalHttpClient {\n  return new InternalHttpClient({\n    host: process.env.PLATFORM_SERVICE_HOST || 'platform',\n    port: parseInt(process.env.PLATFORM_SERVICE_PORT || '3000', 10),\n    timeout: parseInt(process.env.API_KEY_EXCHANGE_TIMEOUT_MS || '3000', 10),\n  });\n}\n\n/** The epoch ms at which a token with `ttlSeconds` of life should be refreshed early. */\nfunction jitteredRefreshAt(issuedAt: number, ttlSeconds: number): number {\n  const lifeMs = ttlSeconds * 1000;\n  const jitter = (Math.random() * 2 - 1) * REFRESH_JITTER_FRACTION;\n  // Clamp into (0, 1) so the refresh point is always before expiry and never in\n  // the past, whatever TTL platform returns.\n  const fraction = Math.min(0.95, Math.max(0.1, REFRESH_AT_FRACTION + jitter));\n  return issuedAt + lifeMs * fraction;\n}\n\n/** Drop the oldest entries once the cache is over its cap (keys are long-lived, tokens are not). */\nfunction evictIfFull(): void {\n  if (tokenCache.size <= MAX_CACHED_KEYS) return;\n  const now = Date.now();\n  for (const [hash, entry] of tokenCache) {\n    if (entry.expiresAt <= now) tokenCache.delete(hash);\n  }\n  // Map preserves insertion order — drop from the front until back under the cap.\n  while (tokenCache.size > MAX_CACHED_KEYS) {\n    const oldest = tokenCache.keys().next();\n    if (oldest.done) break;\n    tokenCache.delete(oldest.value);\n  }\n}\n\ninterface ExchangeResponse {\n  success?: boolean;\n  data?: { accessToken?: string; expiresIn?: number };\n}\n\n/** One real round-trip to platform. Throws the two typed errors above. */\nasync function performExchange(key: string, hash: string): Promise<CacheEntry> {\n  const client = platformClient();\n  let status: number;\n  let body: ExchangeResponse;\n  try {\n    const res = await client.post<ExchangeResponse>('/auth/token/exchange', { key }, {\n      headers: {\n        Authorization: getServiceAuthHeader({ serviceName, role: 'member', orgId: SYSTEM_ORG_ID }),\n      },\n      // The exchange is a pure read of the key record plus a token mint — safe to\n      // retry, and a lost retry only costs one extra mint.\n      idempotent: true,\n    });\n    status = res.statusCode;\n    body = res.body;\n  } catch (err) {\n    emitCounter('api_key_exchange_total', { result: 'unavailable' });\n    emitCounter('api_key_exchange_failures_total', { reason: 'unavailable' });\n    logger.warn('Access-key exchange failed to reach platform', {\n      error: err instanceof Error ? err.message : String(err),\n    });\n    throw new ApiKeyExchangeUnavailableError();\n  }\n\n  if (status === 401 || status === 403 || status === 400 || status === 404) {\n    rejectionCache.set(hash, Date.now() + NEGATIVE_TTL_MS);\n    emitCounter('api_key_exchange_total', { result: 'rejected' });\n    emitCounter('api_key_exchange_failures_total', { reason: 'rejected' });\n    throw new ApiKeyRejectedError();\n  }\n\n  const accessToken = body?.data?.accessToken;\n  if (status >= 400 || typeof accessToken !== 'string' || accessToken.length === 0) {\n    // 429 and 5xx land here: platform is up but can't answer right now, which is\n    // \"unknown\", not \"invalid\" — never cache it as a rejection.\n    emitCounter('api_key_exchange_total', { result: 'unavailable' });\n    emitCounter('api_key_exchange_failures_total', { reason: status === 429 ? 'throttled' : 'server_error' });\n    throw new ApiKeyExchangeUnavailableError();\n  }\n\n  const ttlSeconds = typeof body?.data?.expiresIn === 'number' && body.data.expiresIn > 0\n    ? body.data.expiresIn\n    : 60;\n  const now = Date.now();\n  const entry: CacheEntry = {\n    token: accessToken,\n    expiresAt: now + ttlSeconds * 1000,\n    refreshAt: jitteredRefreshAt(now, ttlSeconds),\n  };\n  tokenCache.set(hash, entry);\n  rejectionCache.delete(hash);\n  evictIfFull();\n  emitCounter('api_key_exchange_total', { result: 'success' });\n  return entry;\n}\n\n/** Exchange, sharing a single in-flight round-trip per key. */\nfunction exchangeOnce(key: string, hash: string): Promise<CacheEntry> {\n  const pending = inFlight.get(hash);\n  if (pending) return pending;\n  const promise = performExchange(key, hash).finally(() => inFlight.delete(hash));\n  inFlight.set(hash, promise);\n  return promise;\n}\n\n/**\n * The JWT for `key`, from cache when possible. Throws {@link ApiKeyRejectedError}\n * when platform refused the key and {@link ApiKeyExchangeUnavailableError} when\n * it could not be asked.\n */\nexport async function exchangeApiKey(key: string): Promise<string> {\n  const hash = hashApiKey(key);\n  const now = Date.now();\n\n  const rejectedUntil = rejectionCache.get(hash);\n  if (rejectedUntil !== undefined) {\n    if (rejectedUntil > now) {\n      emitCounter('api_key_exchange_cache_total', { result: 'rejected' });\n      throw new ApiKeyRejectedError();\n    }\n    rejectionCache.delete(hash);\n  }\n\n  const cached = tokenCache.get(hash);\n  if (cached && cached.expiresAt > now) {\n    if (cached.refreshAt <= now && !inFlight.has(hash)) {\n      // Early refresh: warm the cache WITHOUT making this request wait. A failed\n      // background refresh is not this request's problem — the cached token is\n      // still valid, and the next request past expiry exchanges inline.\n      emitCounter('api_key_exchange_cache_total', { result: 'refresh' });\n      void exchangeOnce(key, hash).catch(() => { /* logged + counted in performExchange */ });\n    } else {\n      emitCounter('api_key_exchange_cache_total', { result: 'hit' });\n    }\n    return cached.token;\n  }\n\n  emitCounter('api_key_exchange_cache_total', { result: 'miss' });\n  return (await exchangeOnce(key, hash)).token;\n}\n\n/**\n * Drop every cached exchange. For tests and for a process that wants to force\n * re-validation; production relies on the TTLs above.\n */\nexport function resetApiKeyExchangeCache(): void {\n  tokenCache.clear();\n  rejectionCache.clear();\n  inFlight.clear();\n}\n"]}

package/lib/services/audit-spool.d.ts

@@ -67,10 +67,9 @@ export declare function createRedisAuditSpool(redis: RedisListClient, opts?: {
     key?: string;
 }): AuditSpool;
 /**
- * Build a Redis-backed audit spool from the ambient `REDIS_URL` / `REDIS_HOST`
+ * Build a Redis-backed audit spool from the ambient `REDIS_URL` / `REDIS_SENTINELS`
  * env via the shared `createEnvRedisClient`. Returns `null` when Redis is not
- * configured or the client can't be constructed — the caller then runs without a
- * spool (pre-spool best-effort behavior), never crashing. The shared helper loads
+ * configured — the caller then runs without a spool (best-effort behavior). The shared helper loads
  * ioredis via `createRequire`, so this stays importable where Redis isn't present.
  */
 export declare function createEnvRedisAuditSpool(opts?: {