@pipeline-builder/api-core 5.2.9 → 5.2.11

package/lib/middleware/auth.d.ts

@@ -44,6 +44,20 @@ export interface RequireAuthOptions {
      * is being asked.
      */
     maxAge?: number;
+    /**
+     * Out-of-cluster service signers this route trusts (`OPT_IN_SERVICE_SIGNERS`
+     * in `services/service-keys.ts` — today only `'deploy-bootstrap'`, whose
+     * private key lives on the operator / CI host rather than in any pod).
+     *
+     * By default EVERY route refuses such a token with **401 `TOKEN_INVALID`**,
+     * exactly as if its key were not in the bundle — the deploy key's public half
+     * is mounted everywhere, so trusting it must be a per-route decision, not an
+     * inherited one. Opting in admits the token as a plain service principal: it
+     * still carries no superadmin or org-admin authority (no service token does),
+     * so the route must gate on its NAME (`isServicePrincipalNamed`) and/or its
+     * explicit `permissions` claim.
+     */
+    acceptServices?: readonly string[];
 }
 /** JWT auth middleware. Use directly or call with options. */
 export declare function requireAuth(req: Request, res: Response, next: NextFunction): void;

package/lib/middleware/auth.js

@@ -89,7 +89,7 @@ async function verifyAndAttach(options, rawToken, req, res, next) {
         // declare itself a service principal. Both pin the algorithm (no
         // alg-confusion, no `alg:none`) and both apply the optional issuer/audience
         // binding.
-        const decoded = await verifyBearerToken(rawToken);
+        const decoded = await verifyBearerToken(rawToken, options.acceptServices ? { acceptServices: options.acceptServices } : {});
         if (decoded.type !== 'access') {
             return sendError(res, HttpStatus.UNAUTHORIZED, 'Only access tokens can be used for API requests', ErrorCode.TOKEN_INVALID);
         }
@@ -137,7 +137,10 @@ async function verifyAndAttach(options, rawToken, req, res, next) {
         // here so that even a route which mistakenly enables `allowOrgHeaderOverride`
         // can NEVER let an ordinary authenticated user spoof another tenant's org via
         // the header — defence-in-depth against the cross-tenant break this caused.
-        if (options.allowOrgHeaderOverride && decoded.isSuperAdmin === true) {
+        // A SERVICE principal never reaches it: its `isSuperAdmin` is stripped at
+        // verification, and the principal-type check keeps it that way if that ever
+        // regressed.
+        if (options.allowOrgHeaderOverride && decoded.isSuperAdmin === true && decoded.principalType !== 'service') {
             const headerOrgId = getHeaderString(req.headers['x-org-id']);
             const headerOrgName = getHeaderString(req.headers['x-org-name']);
             if (headerOrgId)
@@ -200,4 +203,4 @@ async function verifyAndAttach(options, rawToken, req, res, next) {
         return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication failed', ErrorCode.UNAUTHORIZED);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sources":["../../src/middleware/auth.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * `requireAuth`: bearer / access-key authentication, the checks every\n * verified request passes, and the tenant identity it attaches.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport jwt from 'jsonwebtoken';\nimport { refuseForAssurance } from './assurance.js';\nimport { clientVersionOf } from './client-version.js';\nimport { runDeferredQuotaCheck } from './deferred-quota-check.js';\nimport { hasValidIdentityClaims, verifyBearerToken } from './jwt-verify.js';\nimport { recordAuthzDenial } from './permission-gates.js';\nimport { checkRevocation, isImpersonationWriteBlocked, needsRevocationCheck } from './revocation.js';\nimport { tagRouteGate } from './route-table.js';\nimport { isServiceTokenDenied, serviceNameOf } from './service-tokens.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport { JwksUnavailableError, UnknownKidError } from '../services/jwks-cache.js';\nimport { ServiceKeyError, serviceIdentity } from '../services/service-keys.js';\nimport { type AssuranceLevel } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport type { HttpRequest } from '../types/http.js';\nimport { isOpaqueApiKey } from '../utils/api-key.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { getIdentity, type RequestIdentity } from '../utils/identity.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('auth-middleware');\nexport interface RequireAuthOptions {\n  /**\n   * Allow x-org-id/x-org-name headers to override the JWT's organization fields.\n   *\n   * When enabled, the `x-org-id`/`x-org-name` headers override the caller's org\n   * — but ONLY for a verified SYS-ADMIN (`isSuperAdmin` claim). For any ordinary\n   * authenticated user the headers are ignored, so enabling this can never let a\n   * normal user impersonate another tenant's org. Use for cross-org admin tooling\n   * (e.g. a sysadmin managing a given org's billing). If unsure, leave it disabled.\n   */\n  allowOrgHeaderOverride?: boolean;\n  /**\n   * Demand that the whole SESSION be at least this assurance level.\n   *\n   * `minAssurance: 2` means the person authenticated with a second factor — a\n   * passkey with user verification, a password plus an authenticator code, or\n   * SSO through an IdP the org marked as enforcing MFA. A weaker token gets\n   * **401 `MFA_REQUIRED`**, which the client answers by sending the person to\n   * enrolment or to a stronger sign-in; refreshing cannot help, because `aal`\n   * lives on the session slot and a refresh never raises it.\n   *\n   * This is the SESSION-level counterpart to {@link requireStepUp}, which stays\n   * a fresh, per-action confirmation. Use both on the most dangerous routes.\n   *\n   * MACHINES NEVER SATISFY IT. A service principal, an org service account and\n   * an exchanged access key all get **403 `HUMAN_SESSION_REQUIRED`** — there is\n   * no person behind them to have presented a factor, so \"assurance\" is not a\n   * question their credential can answer. That is deliberately not a silent\n   * pass-through for internal services: a route that demands MFA is a route a\n   * human is doing something dangerous on.\n   */\n  minAssurance?: AssuranceLevel;\n  /**\n   * With {@link minAssurance}, additionally bound how long ago that sign-in\n   * happened (seconds, compared against the token's `auth_time`). A session that\n   * is MFA-grade but older than this gets **401 `REAUTH_REQUIRED`**. Ignored\n   * without `minAssurance` — \"how recent\" is only meaningful once \"how strong\"\n   * is being asked.\n   */\n  maxAge?: number;\n}\n\n/** JWT auth middleware. Use directly or call with options. */\nexport function requireAuth(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void;\nexport function requireAuth(\n  options?: RequireAuthOptions,\n): (req: Request, res: Response, next: NextFunction) => void;\nexport function requireAuth(\n  reqOrOptions?: Request | RequireAuthOptions,\n  res?: Response,\n  next?: NextFunction,\n): void | ((req: Request, res: Response, next: NextFunction) => void) {\n  if (reqOrOptions && res && next && 'headers' in reqOrOptions) {\n    return _requireAuth({}, reqOrOptions as Request, res, next);\n  }\n\n  const options = (reqOrOptions as RequireAuthOptions) || {};\n  const gate = tagRouteGate((req: Request, resInner: Response, nextInner: NextFunction) => {\n    _requireAuth(options, req, resInner, nextInner);\n  }, { kind: 'auth' });\n  if (options.minAssurance) {\n    tagRouteGate(gate, { kind: 'assurance', minAssurance: options.minAssurance, ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}) });\n  }\n  return gate;\n}\ntagRouteGate(requireAuth, { kind: 'auth' });\n\nfunction _requireAuth(\n  options: RequireAuthOptions,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  const authHeader = req.headers.authorization;\n\n  if (!authHeader) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authorization header required', ErrorCode.TOKEN_MISSING);\n  }\n\n  const parts = authHeader.split(' ');\n  if (parts.length !== 2 || parts[0] !== 'Bearer') {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid authorization format. Use: Bearer <token>', ErrorCode.TOKEN_INVALID);\n  }\n\n  // An OPAQUE ACCESS KEY (`pb_pat_…` / `pb_sa_…`) carries no claims and no\n  // signature, so it cannot be verified here. Trade it at platform for a\n  // short-lived JWT (cached in-process until it expires) and then verify that\n  // JWT on the normal path — services never read a key hash. See\n  // `services/api-key-exchange.ts`.\n  if (isOpaqueApiKey(parts[1])) {\n    void resolveApiKey(options, parts[1], req, res, next);\n    return;\n  }\n\n  // `.catch(next)` forwards a DOWNSTREAM synchronous throw from `next()` to\n  // Express's error middleware — verification itself never rejects (it maps\n  // every failure to a response).\n  void verifyAndAttach(options, parts[1], req, res, next).catch(next);\n}\n\n/**\n * Exchange an opaque key for a JWT, then continue on the normal verification\n * path. A refused key is a 401; an unreachable platform is a 503 (never a pass —\n * an unverifiable credential is not an identity).\n */\nasync function resolveApiKey(\n  options: RequireAuthOptions,\n  key: string,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): Promise<void> {\n  // Loaded LAZILY, on the first key ever presented. A static import would put\n  // the HTTP client (and platform's address) into the import graph of every\n  // module that merely uses `requireAuth`, which both widens the boot graph and\n  // breaks any test that mocks `http-client.js` with a partial module.\n  const { exchangeApiKey, ApiKeyExchangeUnavailableError } = await import('../services/api-key-exchange.js');\n  let token: string;\n  try {\n    token = await exchangeApiKey(key, clientVersionOf(req));\n  } catch (error) {\n    if (error instanceof ApiKeyExchangeUnavailableError) {\n      return sendError(\n        res, HttpStatus.SERVICE_UNAVAILABLE,\n        'Access-key verification is temporarily unavailable; please retry',\n        ErrorCode.SERVICE_UNAVAILABLE,\n      );\n    }\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid or revoked access key', ErrorCode.TOKEN_INVALID);\n  }\n  await verifyAndAttach(options, token, req, res, next);\n}\n\nasync function verifyAndAttach(\n  options: RequireAuthOptions,\n  rawToken: string,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): Promise<void> {\n  try {\n    // Two chains, one entry point (see `verifyBearerToken`): a user token must\n    // be ES256 signed by platform and verified against its published JWKS; an\n    // internal service token must be ES256 signed by that service's OWN key and\n    // declare itself a service principal. Both pin the algorithm (no\n    // alg-confusion, no `alg:none`) and both apply the optional issuer/audience\n    // binding.\n    const decoded = await verifyBearerToken(rawToken);\n\n    if (decoded.type !== 'access') {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Only access tokens can be used for API requests', ErrorCode.TOKEN_INVALID);\n    }\n\n    if (!decoded.sub || !decoded.role || !hasValidIdentityClaims(decoded)) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token missing required fields', ErrorCode.TOKEN_INVALID);\n    }\n\n    // Service-token kill-switch: reject a service principal whose service has\n    // been added to the denylist. Otherwise the only way to invalidate a\n    // service's tokens before their (short) TTL is rotating that service's\n    // signing key; this cuts one compromised/rogue service off immediately. O(1) Set lookup, zero cost when the denylist\n    // is empty (the default), so it never taxes the S2S hot path unless armed.\n    if (isServiceTokenDenied(decoded)) {\n      emitCounter('service_token_denied_total', { service: serviceNameOf(decoded) ?? 'unknown' });\n      logger.warn('Rejected denylisted service token', { sub: decoded.sub });\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Service token revoked', ErrorCode.TOKEN_REVOKED);\n    }\n\n    req.user = { ...decoded };\n\n    // READ-ONLY IMPERSONATION. The token names the operator AND says it may only\n    // look: every service refuses a state change under it, not only platform —\n    // a support session that could write to plugin/compliance/billing is not\n    // read-only. Checked before any other gate so no route can forget it.\n    if (isImpersonationWriteBlocked(req.method, decoded)) {\n      if (req.method) recordAuthzDenial(req, 'impersonation-read-only');\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        'Write requests are disabled during read-only impersonation. Stop impersonating to make changes.',\n        ErrorCode.IMPERSONATION_READ_ONLY,\n      );\n    }\n\n    // BOOTSTRAP-ADMIN ENROLMENT SESSION. Such a token exists so\n    // the install's only admin can enrol a factor; it is `aal: 1` and must not\n    // reach anything else. Platform — which owns the exception and knows which\n    // of its own routes `init-platform.sh` calls — allows an explicit few before\n    // this point (see its own `requireAuth`); in EVERY other service the answer\n    // is simply no, so the reach restriction holds without a per-service\n    // allowlist to keep in sync.\n    if (decoded.mfaEnrollmentPending === true) {\n      emitCounter('mfa_enforcement_refused_total', { service: serviceIdentity(), reason: 'bootstrap_session' });\n      recordAuthzDenial(req, 'mfa-enrolment');\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        'Finish setting up two-factor authentication before using the rest of Pipeline Builder',\n        ErrorCode.MFA_ENROLLMENT_REQUIRED,\n      );\n    }\n\n    // Session-level assurance (`requireAuth({ minAssurance, maxAge })`).\n    if (options.minAssurance\n      && refuseForAssurance({ minAssurance: options.minAssurance, ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}) }, decoded, req, res)) return;\n\n    // The x-org-id/x-org-name override lets a SYS-ADMIN act on a chosen org\n    // (cross-org admin tooling). It is gated on the verified `isSuperAdmin` claim\n    // here so that even a route which mistakenly enables `allowOrgHeaderOverride`\n    // can NEVER let an ordinary authenticated user spoof another tenant's org via\n    // the header — defence-in-depth against the cross-tenant break this caused.\n    if (options.allowOrgHeaderOverride && decoded.isSuperAdmin === true) {\n      const headerOrgId = getHeaderString(req.headers['x-org-id']);\n      const headerOrgName = getHeaderString(req.headers['x-org-name']);\n      if (headerOrgId) req.user.organizationId = headerOrgId;\n      if (headerOrgName) req.user.organizationName = headerOrgName;\n    }\n\n    // Re-derive the request's tenant identity from the NOW-verified JWT.\n    //\n    // `attachRequestContext` runs as a global middleware BEFORE this per-route\n    // `requireAuth`, so it captured `req.context.identity` while `req.user` was\n    // still undefined — at which point `getIdentity` falls back to the raw,\n    // client-settable `x-org-id`/`x-user-id` headers. Every downstream tenant-\n    // authority consumer (requireOrgId, withTenantContext's RLS scope, checkQuota,\n    // withRoute, and the idempotency namespace) reads `req.context.identity`, so\n    // that frozen header-derived value — not the JWT — was governing tenancy on\n    // any non-nginx path. Recomputing here, at the single post-verification choke\n    // point, makes `getIdentity` prefer the verified `req.user` (see identity.ts)\n    // so tenancy is JWT-authoritative. The nginx `x-org-id` overwrite stays as\n    // defence-in-depth. Guarded on `req.context` so services/paths that never\n    // attach a context (or run requireAuth pre-context) are unaffected.\n    const reqCtx = (req as Request & { context?: { identity: RequestIdentity } }).context;\n    if (reqCtx) {\n      reqCtx.identity = getIdentity(req as unknown as HttpRequest);\n    }\n\n    // Session invalidation (token-version store + impersonation-session\n    // liveness). No store registered ⇒ only impersonation sessions are checked.\n    if (needsRevocationCheck(decoded)) {\n      // `.catch(next)` forwards a DOWNSTREAM synchronous throw from `next()` to\n      // Express's error middleware — this `next()` runs in a microtask, outside\n      // the surrounding try/catch. The check itself never rejects.\n      checkRevocation(decoded).then((refusal) => {\n        if (refusal) return sendError(res, HttpStatus.UNAUTHORIZED, refusal, ErrorCode.TOKEN_REVOKED);\n        runDeferredQuotaCheck(req, res, next);\n      }).catch(next);\n      return;\n    }\n\n    // The apiCalls check a mount armed (api-server `apiCallsQuota`) runs here,\n    // now that tenancy is JWT-authoritative; a plain next() where none was armed.\n    runDeferredQuotaCheck(req, res, next);\n  } catch (error) {\n    if (error instanceof jwt.TokenExpiredError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token has expired', ErrorCode.TOKEN_EXPIRED);\n    }\n\n    // The signing keys couldn't be fetched, so the token's validity is UNKNOWN.\n    // Fail CLOSED with a retryable 503 — never a pass, and never a 401 that\n    // would send a legitimate client off to re-authenticate over our outage.\n    // Same reasoning for the SERVICE chain: no readable key bundle means no way\n    // to tell a peer's token from a forgery, so the request is refused with a\n    // retryable 503 rather than admitted or bounced to re-authenticate.\n    if (error instanceof JwksUnavailableError || error instanceof ServiceKeyError) {\n      logger.warn('Rejecting request: token signing keys unavailable', { error: error.message });\n      return sendError(\n        res, HttpStatus.SERVICE_UNAVAILABLE,\n        'Token verification is temporarily unavailable; please retry',\n        ErrorCode.SERVICE_UNAVAILABLE,\n      );\n    }\n\n    if (error instanceof UnknownKidError || error instanceof jwt.JsonWebTokenError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid token', ErrorCode.TOKEN_INVALID);\n    }\n\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication failed', ErrorCode.UNAUTHORIZED);\n  }\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sources":["../../src/middleware/auth.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * `requireAuth`: bearer / access-key authentication, the checks every\n * verified request passes, and the tenant identity it attaches.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport jwt from 'jsonwebtoken';\nimport { refuseForAssurance } from './assurance.js';\nimport { clientVersionOf } from './client-version.js';\nimport { runDeferredQuotaCheck } from './deferred-quota-check.js';\nimport { hasValidIdentityClaims, verifyBearerToken } from './jwt-verify.js';\nimport { recordAuthzDenial } from './permission-gates.js';\nimport { checkRevocation, isImpersonationWriteBlocked, needsRevocationCheck } from './revocation.js';\nimport { tagRouteGate } from './route-table.js';\nimport { isServiceTokenDenied, serviceNameOf } from './service-tokens.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport { JwksUnavailableError, UnknownKidError } from '../services/jwks-cache.js';\nimport { ServiceKeyError, serviceIdentity } from '../services/service-keys.js';\nimport { type AssuranceLevel } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport type { HttpRequest } from '../types/http.js';\nimport { isOpaqueApiKey } from '../utils/api-key.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { getIdentity, type RequestIdentity } from '../utils/identity.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('auth-middleware');\nexport interface RequireAuthOptions {\n  /**\n   * Allow x-org-id/x-org-name headers to override the JWT's organization fields.\n   *\n   * When enabled, the `x-org-id`/`x-org-name` headers override the caller's org\n   * — but ONLY for a verified SYS-ADMIN (`isSuperAdmin` claim). For any ordinary\n   * authenticated user the headers are ignored, so enabling this can never let a\n   * normal user impersonate another tenant's org. Use for cross-org admin tooling\n   * (e.g. a sysadmin managing a given org's billing). If unsure, leave it disabled.\n   */\n  allowOrgHeaderOverride?: boolean;\n  /**\n   * Demand that the whole SESSION be at least this assurance level.\n   *\n   * `minAssurance: 2` means the person authenticated with a second factor — a\n   * passkey with user verification, a password plus an authenticator code, or\n   * SSO through an IdP the org marked as enforcing MFA. A weaker token gets\n   * **401 `MFA_REQUIRED`**, which the client answers by sending the person to\n   * enrolment or to a stronger sign-in; refreshing cannot help, because `aal`\n   * lives on the session slot and a refresh never raises it.\n   *\n   * This is the SESSION-level counterpart to {@link requireStepUp}, which stays\n   * a fresh, per-action confirmation. Use both on the most dangerous routes.\n   *\n   * MACHINES NEVER SATISFY IT. A service principal, an org service account and\n   * an exchanged access key all get **403 `HUMAN_SESSION_REQUIRED`** — there is\n   * no person behind them to have presented a factor, so \"assurance\" is not a\n   * question their credential can answer. That is deliberately not a silent\n   * pass-through for internal services: a route that demands MFA is a route a\n   * human is doing something dangerous on.\n   */\n  minAssurance?: AssuranceLevel;\n  /**\n   * With {@link minAssurance}, additionally bound how long ago that sign-in\n   * happened (seconds, compared against the token's `auth_time`). A session that\n   * is MFA-grade but older than this gets **401 `REAUTH_REQUIRED`**. Ignored\n   * without `minAssurance` — \"how recent\" is only meaningful once \"how strong\"\n   * is being asked.\n   */\n  maxAge?: number;\n  /**\n   * Out-of-cluster service signers this route trusts (`OPT_IN_SERVICE_SIGNERS`\n   * in `services/service-keys.ts` — today only `'deploy-bootstrap'`, whose\n   * private key lives on the operator / CI host rather than in any pod).\n   *\n   * By default EVERY route refuses such a token with **401 `TOKEN_INVALID`**,\n   * exactly as if its key were not in the bundle — the deploy key's public half\n   * is mounted everywhere, so trusting it must be a per-route decision, not an\n   * inherited one. Opting in admits the token as a plain service principal: it\n   * still carries no superadmin or org-admin authority (no service token does),\n   * so the route must gate on its NAME (`isServicePrincipalNamed`) and/or its\n   * explicit `permissions` claim.\n   */\n  acceptServices?: readonly string[];\n}\n\n/** JWT auth middleware. Use directly or call with options. */\nexport function requireAuth(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void;\nexport function requireAuth(\n  options?: RequireAuthOptions,\n): (req: Request, res: Response, next: NextFunction) => void;\nexport function requireAuth(\n  reqOrOptions?: Request | RequireAuthOptions,\n  res?: Response,\n  next?: NextFunction,\n): void | ((req: Request, res: Response, next: NextFunction) => void) {\n  if (reqOrOptions && res && next && 'headers' in reqOrOptions) {\n    return _requireAuth({}, reqOrOptions as Request, res, next);\n  }\n\n  const options = (reqOrOptions as RequireAuthOptions) || {};\n  const gate = tagRouteGate((req: Request, resInner: Response, nextInner: NextFunction) => {\n    _requireAuth(options, req, resInner, nextInner);\n  }, { kind: 'auth' });\n  if (options.minAssurance) {\n    tagRouteGate(gate, { kind: 'assurance', minAssurance: options.minAssurance, ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}) });\n  }\n  return gate;\n}\ntagRouteGate(requireAuth, { kind: 'auth' });\n\nfunction _requireAuth(\n  options: RequireAuthOptions,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  const authHeader = req.headers.authorization;\n\n  if (!authHeader) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authorization header required', ErrorCode.TOKEN_MISSING);\n  }\n\n  const parts = authHeader.split(' ');\n  if (parts.length !== 2 || parts[0] !== 'Bearer') {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid authorization format. Use: Bearer <token>', ErrorCode.TOKEN_INVALID);\n  }\n\n  // An OPAQUE ACCESS KEY (`pb_pat_…` / `pb_sa_…`) carries no claims and no\n  // signature, so it cannot be verified here. Trade it at platform for a\n  // short-lived JWT (cached in-process until it expires) and then verify that\n  // JWT on the normal path — services never read a key hash. See\n  // `services/api-key-exchange.ts`.\n  if (isOpaqueApiKey(parts[1])) {\n    void resolveApiKey(options, parts[1], req, res, next);\n    return;\n  }\n\n  // `.catch(next)` forwards a DOWNSTREAM synchronous throw from `next()` to\n  // Express's error middleware — verification itself never rejects (it maps\n  // every failure to a response).\n  void verifyAndAttach(options, parts[1], req, res, next).catch(next);\n}\n\n/**\n * Exchange an opaque key for a JWT, then continue on the normal verification\n * path. A refused key is a 401; an unreachable platform is a 503 (never a pass —\n * an unverifiable credential is not an identity).\n */\nasync function resolveApiKey(\n  options: RequireAuthOptions,\n  key: string,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): Promise<void> {\n  // Loaded LAZILY, on the first key ever presented. A static import would put\n  // the HTTP client (and platform's address) into the import graph of every\n  // module that merely uses `requireAuth`, which both widens the boot graph and\n  // breaks any test that mocks `http-client.js` with a partial module.\n  const { exchangeApiKey, ApiKeyExchangeUnavailableError } = await import('../services/api-key-exchange.js');\n  let token: string;\n  try {\n    token = await exchangeApiKey(key, clientVersionOf(req));\n  } catch (error) {\n    if (error instanceof ApiKeyExchangeUnavailableError) {\n      return sendError(\n        res, HttpStatus.SERVICE_UNAVAILABLE,\n        'Access-key verification is temporarily unavailable; please retry',\n        ErrorCode.SERVICE_UNAVAILABLE,\n      );\n    }\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid or revoked access key', ErrorCode.TOKEN_INVALID);\n  }\n  await verifyAndAttach(options, token, req, res, next);\n}\n\nasync function verifyAndAttach(\n  options: RequireAuthOptions,\n  rawToken: string,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): Promise<void> {\n  try {\n    // Two chains, one entry point (see `verifyBearerToken`): a user token must\n    // be ES256 signed by platform and verified against its published JWKS; an\n    // internal service token must be ES256 signed by that service's OWN key and\n    // declare itself a service principal. Both pin the algorithm (no\n    // alg-confusion, no `alg:none`) and both apply the optional issuer/audience\n    // binding.\n    const decoded = await verifyBearerToken(\n      rawToken,\n      options.acceptServices ? { acceptServices: options.acceptServices } : {},\n    );\n\n    if (decoded.type !== 'access') {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Only access tokens can be used for API requests', ErrorCode.TOKEN_INVALID);\n    }\n\n    if (!decoded.sub || !decoded.role || !hasValidIdentityClaims(decoded)) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token missing required fields', ErrorCode.TOKEN_INVALID);\n    }\n\n    // Service-token kill-switch: reject a service principal whose service has\n    // been added to the denylist. Otherwise the only way to invalidate a\n    // service's tokens before their (short) TTL is rotating that service's\n    // signing key; this cuts one compromised/rogue service off immediately. O(1) Set lookup, zero cost when the denylist\n    // is empty (the default), so it never taxes the S2S hot path unless armed.\n    if (isServiceTokenDenied(decoded)) {\n      emitCounter('service_token_denied_total', { service: serviceNameOf(decoded) ?? 'unknown' });\n      logger.warn('Rejected denylisted service token', { sub: decoded.sub });\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Service token revoked', ErrorCode.TOKEN_REVOKED);\n    }\n\n    req.user = { ...decoded };\n\n    // READ-ONLY IMPERSONATION. The token names the operator AND says it may only\n    // look: every service refuses a state change under it, not only platform —\n    // a support session that could write to plugin/compliance/billing is not\n    // read-only. Checked before any other gate so no route can forget it.\n    if (isImpersonationWriteBlocked(req.method, decoded)) {\n      if (req.method) recordAuthzDenial(req, 'impersonation-read-only');\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        'Write requests are disabled during read-only impersonation. Stop impersonating to make changes.',\n        ErrorCode.IMPERSONATION_READ_ONLY,\n      );\n    }\n\n    // BOOTSTRAP-ADMIN ENROLMENT SESSION. Such a token exists so\n    // the install's only admin can enrol a factor; it is `aal: 1` and must not\n    // reach anything else. Platform — which owns the exception and knows which\n    // of its own routes `init-platform.sh` calls — allows an explicit few before\n    // this point (see its own `requireAuth`); in EVERY other service the answer\n    // is simply no, so the reach restriction holds without a per-service\n    // allowlist to keep in sync.\n    if (decoded.mfaEnrollmentPending === true) {\n      emitCounter('mfa_enforcement_refused_total', { service: serviceIdentity(), reason: 'bootstrap_session' });\n      recordAuthzDenial(req, 'mfa-enrolment');\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        'Finish setting up two-factor authentication before using the rest of Pipeline Builder',\n        ErrorCode.MFA_ENROLLMENT_REQUIRED,\n      );\n    }\n\n    // Session-level assurance (`requireAuth({ minAssurance, maxAge })`).\n    if (options.minAssurance\n      && refuseForAssurance({ minAssurance: options.minAssurance, ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}) }, decoded, req, res)) return;\n\n    // The x-org-id/x-org-name override lets a SYS-ADMIN act on a chosen org\n    // (cross-org admin tooling). It is gated on the verified `isSuperAdmin` claim\n    // here so that even a route which mistakenly enables `allowOrgHeaderOverride`\n    // can NEVER let an ordinary authenticated user spoof another tenant's org via\n    // the header — defence-in-depth against the cross-tenant break this caused.\n    // A SERVICE principal never reaches it: its `isSuperAdmin` is stripped at\n    // verification, and the principal-type check keeps it that way if that ever\n    // regressed.\n    if (options.allowOrgHeaderOverride && decoded.isSuperAdmin === true && decoded.principalType !== 'service') {\n      const headerOrgId = getHeaderString(req.headers['x-org-id']);\n      const headerOrgName = getHeaderString(req.headers['x-org-name']);\n      if (headerOrgId) req.user.organizationId = headerOrgId;\n      if (headerOrgName) req.user.organizationName = headerOrgName;\n    }\n\n    // Re-derive the request's tenant identity from the NOW-verified JWT.\n    //\n    // `attachRequestContext` runs as a global middleware BEFORE this per-route\n    // `requireAuth`, so it captured `req.context.identity` while `req.user` was\n    // still undefined — at which point `getIdentity` falls back to the raw,\n    // client-settable `x-org-id`/`x-user-id` headers. Every downstream tenant-\n    // authority consumer (requireOrgId, withTenantContext's RLS scope, checkQuota,\n    // withRoute, and the idempotency namespace) reads `req.context.identity`, so\n    // that frozen header-derived value — not the JWT — was governing tenancy on\n    // any non-nginx path. Recomputing here, at the single post-verification choke\n    // point, makes `getIdentity` prefer the verified `req.user` (see identity.ts)\n    // so tenancy is JWT-authoritative. The nginx `x-org-id` overwrite stays as\n    // defence-in-depth. Guarded on `req.context` so services/paths that never\n    // attach a context (or run requireAuth pre-context) are unaffected.\n    const reqCtx = (req as Request & { context?: { identity: RequestIdentity } }).context;\n    if (reqCtx) {\n      reqCtx.identity = getIdentity(req as unknown as HttpRequest);\n    }\n\n    // Session invalidation (token-version store + impersonation-session\n    // liveness). No store registered ⇒ only impersonation sessions are checked.\n    if (needsRevocationCheck(decoded)) {\n      // `.catch(next)` forwards a DOWNSTREAM synchronous throw from `next()` to\n      // Express's error middleware — this `next()` runs in a microtask, outside\n      // the surrounding try/catch. The check itself never rejects.\n      checkRevocation(decoded).then((refusal) => {\n        if (refusal) return sendError(res, HttpStatus.UNAUTHORIZED, refusal, ErrorCode.TOKEN_REVOKED);\n        runDeferredQuotaCheck(req, res, next);\n      }).catch(next);\n      return;\n    }\n\n    // The apiCalls check a mount armed (api-server `apiCallsQuota`) runs here,\n    // now that tenancy is JWT-authoritative; a plain next() where none was armed.\n    runDeferredQuotaCheck(req, res, next);\n  } catch (error) {\n    if (error instanceof jwt.TokenExpiredError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token has expired', ErrorCode.TOKEN_EXPIRED);\n    }\n\n    // The signing keys couldn't be fetched, so the token's validity is UNKNOWN.\n    // Fail CLOSED with a retryable 503 — never a pass, and never a 401 that\n    // would send a legitimate client off to re-authenticate over our outage.\n    // Same reasoning for the SERVICE chain: no readable key bundle means no way\n    // to tell a peer's token from a forgery, so the request is refused with a\n    // retryable 503 rather than admitted or bounced to re-authenticate.\n    if (error instanceof JwksUnavailableError || error instanceof ServiceKeyError) {\n      logger.warn('Rejecting request: token signing keys unavailable', { error: error.message });\n      return sendError(\n        res, HttpStatus.SERVICE_UNAVAILABLE,\n        'Token verification is temporarily unavailable; please retry',\n        ErrorCode.SERVICE_UNAVAILABLE,\n      );\n    }\n\n    if (error instanceof UnknownKidError || error instanceof jwt.JsonWebTokenError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid token', ErrorCode.TOKEN_INVALID);\n    }\n\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication failed', ErrorCode.UNAUTHORIZED);\n  }\n}\n\n"]}

package/lib/middleware/jwt-verify.d.ts

@@ -37,8 +37,15 @@ export declare function verifyUserJwt<T = JwtPayload>(token: string): Promise<T>
  *
  * Anything that is not ES256 with a `kid` fails in both chains, which is what
  * makes "no HS256 token is accepted anywhere" a property of the code.
+ *
+ * A service token comes back with its authority claims reduced (no
+ * `isSuperAdmin`, no org-admin `role`/`isAdmin` — see
+ * `withoutServiceAuthorityClaims`), and one from an out-of-cluster signer
+ * (`deploy-bootstrap`) is refused unless `options.acceptServices` names it.
  */
-export declare function verifyBearerToken(token: string): Promise<JwtPayload>;
+export declare function verifyBearerToken(token: string, options?: {
+    acceptServices?: readonly string[];
+}): Promise<JwtPayload>;
 /**
  * Whether a verified token carries a well-formed identity: a known
  * `principalType` and `token_use`, and the claims that kind of principal must

package/lib/middleware/jwt-verify.js

@@ -57,13 +57,22 @@ export async function verifyUserJwt(token) {
  *
  * Anything that is not ES256 with a `kid` fails in both chains, which is what
  * makes "no HS256 token is accepted anywhere" a property of the code.
+ *
+ * A service token comes back with its authority claims reduced (no
+ * `isSuperAdmin`, no org-admin `role`/`isAdmin` — see
+ * `withoutServiceAuthorityClaims`), and one from an out-of-cluster signer
+ * (`deploy-bootstrap`) is refused unless `options.acceptServices` names it.
  */
-export async function verifyBearerToken(token) {
+export async function verifyBearerToken(token, options = {}) {
     const header = decodeJwtHeader(token);
     if (!header?.alg)
         throw new jwt.JsonWebTokenError('Malformed token header');
     if (header.kid && isServiceKid(header.kid)) {
-        const claims = verifyServiceJwt(token, { kid: header.kid, ...issuerAudienceOptions() });
+        const claims = verifyServiceJwt(token, {
+            kid: header.kid,
+            ...issuerAudienceOptions(),
+            ...(options.acceptServices ? { acceptServices: options.acceptServices } : {}),
+        });
         if (claims.principalType !== 'service') {
             emitCounter('service_key_non_service_token_rejected_total', { alg: header.alg });
             throw new jwt.JsonWebTokenError('A service signing key may only mint a service principal');
@@ -102,4 +111,4 @@ export function hasValidIdentityClaims(decoded) {
         && (decoded.aal === 1 || decoded.aal === 2)
         && typeof decoded.auth_time === 'number';
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jwt-verify.js","sources":["../../src/middleware/jwt-verify.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Bearer-token verification: the user chain (ES256 against platform's JWKS) and\n * the identity-claim shape every gate reasons about.\n */\n\nimport jwt from 'jsonwebtoken';\nimport { platformJwksCache } from '../services/jwks-cache.js';\nimport { SERVICE_SUBJECT_PREFIX, isServiceKid, verifyServiceJwt } from '../services/service-keys.js';\nimport { AUTH_METHODS, PRINCIPAL_TYPES, TOKEN_USES, type JwtPayload } from '../types/common.js';\nimport { USER_TOKEN_ALGORITHM, decodeJwtHeader } from '../utils/jwk.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n/** Issuer/audience pinning, when the deployment configures them. Shared by both chains. */\nexport function issuerAudienceOptions(): { issuer?: string; audience?: string } {\n  return {\n    ...(process.env.JWT_ISSUER ? { issuer: process.env.JWT_ISSUER } : {}),\n    ...(process.env.JWT_AUDIENCE ? { audience: process.env.JWT_AUDIENCE } : {}),\n  };\n}\n\n/**\n * Verify a token that speaks for a PERSON — access, step-up, and the token an\n * opaque access key is exchanged for — against platform's published signing\n * keys.\n *\n * ES256 and a `kid` are both mandatory: no `kid` means no way to pick the right\n * key across a rotation, and any other algorithm is refused outright, which is\n * what makes \"no service accepts an HS256 user token\" a property of the code\n * rather than a convention. Key lookup goes through the shared JWKS cache\n * (10-minute refresh, one refetch on an unknown `kid`, brief negative cache).\n *\n * @throws {UnknownKidError} the key set is current and has no such key → 401.\n * @throws {JwksUnavailableError} the key set could not be obtained → 503; an\n *         unverifiable token is never treated as valid.\n */\nexport async function verifyUserJwt<T = JwtPayload>(token: string): Promise<T> {\n  const header = decodeJwtHeader(token);\n  if (header?.alg !== USER_TOKEN_ALGORITHM || !header.kid) {\n    throw new jwt.JsonWebTokenError(`User tokens must be signed with ${USER_TOKEN_ALGORITHM} and carry a kid`);\n  }\n  const key = await platformJwksCache().getKey(header.kid);\n  return jwt.verify(token, key, { algorithms: [USER_TOKEN_ALGORITHM], ...issuerAudienceOptions() }) as T;\n}\n\n/**\n * Verify ANY bearer token and return its claims.\n *\n * Since #14 there is no shared secret left: BOTH chains are ES256 with a `kid`,\n * so the dispatch is by **who owns the `kid`** rather than by algorithm — and\n * because a `kid` is an RFC 7638 thumbprint, ownership is a fact about the key,\n * not a claim the token makes about itself:\n *\n * - a `kid` published in the per-service key bundle → an INTERNAL SERVICE token\n *   ({@link signServiceToken}), verified with that service's key; its `sub` must\n *   name the same service, so one service can never speak for another.\n * - anything else → a platform-signed USER token, verified against platform's\n *   published JWKS. A token claiming `principalType: 'service'` is refused\n *   here: an internal identity may not ride the user signing key.\n *\n * Anything that is not ES256 with a `kid` fails in both chains, which is what\n * makes \"no HS256 token is accepted anywhere\" a property of the code.\n */\nexport async function verifyBearerToken(token: string): Promise<JwtPayload> {\n  const header = decodeJwtHeader(token);\n  if (!header?.alg) throw new jwt.JsonWebTokenError('Malformed token header');\n\n  if (header.kid && isServiceKid(header.kid)) {\n    const claims = verifyServiceJwt<JwtPayload>(token, { kid: header.kid, ...issuerAudienceOptions() });\n    if (claims.principalType !== 'service') {\n      emitCounter('service_key_non_service_token_rejected_total', { alg: header.alg });\n      throw new jwt.JsonWebTokenError('A service signing key may only mint a service principal');\n    }\n    return claims;\n  }\n\n  const claims = await verifyUserJwt(token);\n  if (claims.principalType === 'service') {\n    throw new jwt.JsonWebTokenError('Service principals may not be signed with the user signing key');\n  }\n  return claims;\n}\n\n/**\n * Whether a verified token carries a well-formed identity: a known\n * `principalType` and `token_use`, and the claims that kind of principal must\n * have. Fails closed — a token minted before these claims existed, or one with a\n * contradictory combination, is not an identity any gate should reason about.\n *\n * - `service`: `token_use: 'access'` and a `service:<name>` subject (the name\n *   feeds the denylist and audit attribution).\n * - `user` / `service_account`: `amr` (known methods), `aal` and `auth_time`.\n */\nexport function hasValidIdentityClaims(decoded: Partial<JwtPayload>): boolean {\n  if (!decoded.principalType || !PRINCIPAL_TYPES.includes(decoded.principalType)) return false;\n  if (!decoded.token_use || !TOKEN_USES.includes(decoded.token_use)) return false;\n  if (decoded.principalType === 'service') {\n    return decoded.token_use === 'access'\n      && typeof decoded.sub === 'string'\n      && decoded.sub.startsWith(SERVICE_SUBJECT_PREFIX)\n      && decoded.sub.length > SERVICE_SUBJECT_PREFIX.length;\n  }\n  return Array.isArray(decoded.amr)\n    && decoded.amr.every((m) => AUTH_METHODS.includes(m))\n    && (decoded.aal === 1 || decoded.aal === 2)\n    && typeof decoded.auth_time === 'number';\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jwt-verify.js","sources":["../../src/middleware/jwt-verify.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Bearer-token verification: the user chain (ES256 against platform's JWKS) and\n * the identity-claim shape every gate reasons about.\n */\n\nimport jwt from 'jsonwebtoken';\nimport { platformJwksCache } from '../services/jwks-cache.js';\nimport { SERVICE_SUBJECT_PREFIX, isServiceKid, verifyServiceJwt } from '../services/service-keys.js';\nimport { AUTH_METHODS, PRINCIPAL_TYPES, TOKEN_USES, type JwtPayload } from '../types/common.js';\nimport { USER_TOKEN_ALGORITHM, decodeJwtHeader } from '../utils/jwk.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n/** Issuer/audience pinning, when the deployment configures them. Shared by both chains. */\nexport function issuerAudienceOptions(): { issuer?: string; audience?: string } {\n  return {\n    ...(process.env.JWT_ISSUER ? { issuer: process.env.JWT_ISSUER } : {}),\n    ...(process.env.JWT_AUDIENCE ? { audience: process.env.JWT_AUDIENCE } : {}),\n  };\n}\n\n/**\n * Verify a token that speaks for a PERSON — access, step-up, and the token an\n * opaque access key is exchanged for — against platform's published signing\n * keys.\n *\n * ES256 and a `kid` are both mandatory: no `kid` means no way to pick the right\n * key across a rotation, and any other algorithm is refused outright, which is\n * what makes \"no service accepts an HS256 user token\" a property of the code\n * rather than a convention. Key lookup goes through the shared JWKS cache\n * (10-minute refresh, one refetch on an unknown `kid`, brief negative cache).\n *\n * @throws {UnknownKidError} the key set is current and has no such key → 401.\n * @throws {JwksUnavailableError} the key set could not be obtained → 503; an\n *         unverifiable token is never treated as valid.\n */\nexport async function verifyUserJwt<T = JwtPayload>(token: string): Promise<T> {\n  const header = decodeJwtHeader(token);\n  if (header?.alg !== USER_TOKEN_ALGORITHM || !header.kid) {\n    throw new jwt.JsonWebTokenError(`User tokens must be signed with ${USER_TOKEN_ALGORITHM} and carry a kid`);\n  }\n  const key = await platformJwksCache().getKey(header.kid);\n  return jwt.verify(token, key, { algorithms: [USER_TOKEN_ALGORITHM], ...issuerAudienceOptions() }) as T;\n}\n\n/**\n * Verify ANY bearer token and return its claims.\n *\n * Since #14 there is no shared secret left: BOTH chains are ES256 with a `kid`,\n * so the dispatch is by **who owns the `kid`** rather than by algorithm — and\n * because a `kid` is an RFC 7638 thumbprint, ownership is a fact about the key,\n * not a claim the token makes about itself:\n *\n * - a `kid` published in the per-service key bundle → an INTERNAL SERVICE token\n *   ({@link signServiceToken}), verified with that service's key; its `sub` must\n *   name the same service, so one service can never speak for another.\n * - anything else → a platform-signed USER token, verified against platform's\n *   published JWKS. A token claiming `principalType: 'service'` is refused\n *   here: an internal identity may not ride the user signing key.\n *\n * Anything that is not ES256 with a `kid` fails in both chains, which is what\n * makes \"no HS256 token is accepted anywhere\" a property of the code.\n *\n * A service token comes back with its authority claims reduced (no\n * `isSuperAdmin`, no org-admin `role`/`isAdmin` — see\n * `withoutServiceAuthorityClaims`), and one from an out-of-cluster signer\n * (`deploy-bootstrap`) is refused unless `options.acceptServices` names it.\n */\nexport async function verifyBearerToken(\n  token: string,\n  options: { acceptServices?: readonly string[] } = {},\n): Promise<JwtPayload> {\n  const header = decodeJwtHeader(token);\n  if (!header?.alg) throw new jwt.JsonWebTokenError('Malformed token header');\n\n  if (header.kid && isServiceKid(header.kid)) {\n    const claims = verifyServiceJwt<JwtPayload>(token, {\n      kid: header.kid,\n      ...issuerAudienceOptions(),\n      ...(options.acceptServices ? { acceptServices: options.acceptServices } : {}),\n    });\n    if (claims.principalType !== 'service') {\n      emitCounter('service_key_non_service_token_rejected_total', { alg: header.alg });\n      throw new jwt.JsonWebTokenError('A service signing key may only mint a service principal');\n    }\n    return claims;\n  }\n\n  const claims = await verifyUserJwt(token);\n  if (claims.principalType === 'service') {\n    throw new jwt.JsonWebTokenError('Service principals may not be signed with the user signing key');\n  }\n  return claims;\n}\n\n/**\n * Whether a verified token carries a well-formed identity: a known\n * `principalType` and `token_use`, and the claims that kind of principal must\n * have. Fails closed — a token minted before these claims existed, or one with a\n * contradictory combination, is not an identity any gate should reason about.\n *\n * - `service`: `token_use: 'access'` and a `service:<name>` subject (the name\n *   feeds the denylist and audit attribution).\n * - `user` / `service_account`: `amr` (known methods), `aal` and `auth_time`.\n */\nexport function hasValidIdentityClaims(decoded: Partial<JwtPayload>): boolean {\n  if (!decoded.principalType || !PRINCIPAL_TYPES.includes(decoded.principalType)) return false;\n  if (!decoded.token_use || !TOKEN_USES.includes(decoded.token_use)) return false;\n  if (decoded.principalType === 'service') {\n    return decoded.token_use === 'access'\n      && typeof decoded.sub === 'string'\n      && decoded.sub.startsWith(SERVICE_SUBJECT_PREFIX)\n      && decoded.sub.length > SERVICE_SUBJECT_PREFIX.length;\n  }\n  return Array.isArray(decoded.amr)\n    && decoded.amr.every((m) => AUTH_METHODS.includes(m))\n    && (decoded.aal === 1 || decoded.aal === 2)\n    && typeof decoded.auth_time === 'number';\n}\n\n"]}

package/lib/middleware/service-tokens.d.ts

@@ -25,10 +25,11 @@ export interface ServiceTokenOptions {
     /** TTL in seconds (default 300). */
     ttlSeconds?: number;
     /**
-     * Role the token carries (required — no implicit default). **Pass the LOWEST
-     * role the call actually needs** (`'member'` for read / data-plane calls) so a
-     * leaked service token can't perform admin actions in the target org.
-     * `isAdmin` is derived from this (admin|owner → true).
+     * Role the token carries (required — no implicit default). Pass `'member'`:
+     * every verifier clamps a service token's `owner`/`admin` role to `member`
+     * and its `isAdmin` to `false` (`withoutServiceAuthorityClaims`), so a higher
+     * role confers nothing on the receiving side. Grant a capability through
+     * {@link permissions} instead.
      */
     role: 'owner' | 'admin' | 'member';
     /**

package/lib/middleware/service-tokens.js

@@ -20,9 +20,16 @@ import { decodeJwtHeader } from '../utils/jwk.js';
 // the claim; the subject names — and since #14 the name is cryptographically
 // bound to the signing key, so it can also be trusted.
 // `requireAuth` accepts these tokens transparently — they pass `decoded.sub`
-// and `decoded.role` checks, and the downstream org/role gates
-// (`requireOrgMembership` in platform's controller helpers, `requireSystemAdmin`)
-// rely on the org/role embedded in the token.
+// and `decoded.role` checks, and downstream tenancy gates read the org embedded
+// in the token.
+//
+// A service token carries NO admin authority, whatever it claims: the verifier
+// (`verifyServiceJwt` → `withoutServiceAuthorityClaims`) drops `isSuperAdmin`,
+// forces `isAdmin: false` and clamps an `owner`/`admin` role to `member`. What a
+// service may do is decided by its NAME (bound to its key —
+// `requireInternalService`, `isServicePrincipalNamed`) and by the explicit
+// `permissions` claim. Tokens from the out-of-cluster `deploy-bootstrap` signer
+// are refused unless the seam opts in (`requireAuth({ acceptServices })`).
 //
 // Tokens default to 5-minute TTL — long enough to survive a backend hop,
 // short enough that a leaked token is low-value.
@@ -157,4 +164,4 @@ export function verifyServicePrincipal(req) {
         return false;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service-tokens.js","sources":["../../src/middleware/service-tokens.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Service-to-service tokens and service-principal checks.\n */\n\nimport { randomUUID } from 'crypto';\nimport type { Request } from 'express';\nimport { hasValidIdentityClaims, issuerAudienceOptions } from './jwt-verify.js';\nimport { SERVICE_SUBJECT_PREFIX, isServiceKid, signServiceJwt, verifyServiceJwt } from '../services/service-keys.js';\nimport { type JwtPayload } from '../types/common.js';\nimport { type Permission } from '../types/permissions.js';\nimport { decodeJwtHeader } from '../utils/jwk.js';\n// ---------------------------------------------------------------------------\n// Service-to-service tokens\n//\n// Inter-service HTTP calls (billing → message, platform → compliance, etc.)\n// need to satisfy the same `requireAuth` middleware as user requests.\n// `signServiceToken` mints a short-lived ES256 JWT signed with THIS service's\n// OWN key (see `services/service-keys.ts`), carrying `principalType: 'service'`\n// and naming the calling service via `sub: 'service:<name>'`. Gates branch on\n// the claim; the subject names — and since #14 the name is cryptographically\n// bound to the signing key, so it can also be trusted.\n// `requireAuth` accepts these tokens transparently — they pass `decoded.sub`\n// and `decoded.role` checks, and the downstream org/role gates\n// (`requireOrgMembership` in platform's controller helpers, `requireSystemAdmin`)\n// rely on the org/role embedded in the token.\n//\n// Tokens default to 5-minute TTL — long enough to survive a backend hop,\n// short enough that a leaked token is low-value.\n// ---------------------------------------------------------------------------\n\nconst DEFAULT_SERVICE_TOKEN_TTL_SECONDS = 300;\n\n/**\n * Denylist of service NAMES (the `<name>` in `sub: service:<name>`) whose tokens\n * `requireAuth` must reject. Read from `SERVICE_TOKEN_DENYLIST` (comma-separated)\n * at process start, so arming it is a config change + rollout — it cuts off a\n * compromised service WITHOUT rotating any key, and without invalidating every\n * other service's tokens as collateral.\n */\nconst serviceTokenDenylist = new Set(\n  (process.env.SERVICE_TOKEN_DENYLIST || '')\n    .split(',')\n    .map((s) => s.trim())\n    .filter(Boolean),\n);\n\n/**\n * The calling service's name for a SERVICE principal (`principalType: 'service'`),\n * else `undefined`. A user token never yields a name, whatever its `sub` says.\n */\nexport function serviceNameOf(claims: { principalType?: string; sub?: string } | undefined): string | undefined {\n  if (claims?.principalType !== 'service' || typeof claims.sub !== 'string') return undefined;\n  if (!claims.sub.startsWith(SERVICE_SUBJECT_PREFIX)) return undefined;\n  return claims.sub.slice(SERVICE_SUBJECT_PREFIX.length) || undefined;\n}\n\n/** True when the claims are a service principal whose service is on the denylist. */\nexport function isServiceTokenDenied(claims: { principalType?: string; sub?: string }): boolean {\n  if (serviceTokenDenylist.size === 0) return false;\n  const name = serviceNameOf(claims);\n  return name !== undefined && serviceTokenDenylist.has(name);\n}\n\nexport interface ServiceTokenOptions {\n  /** Calling service identifier (e.g. 'billing', 'platform'). Embedded as `sub: service:<name>`. */\n  serviceName: string;\n  /** Active org context for the call. Use the target tenant's org id, or the\n   *  well-known `SYSTEM_ORG_ID` (an ObjectId) for system-wide ops — NOT the string\n   *  'system', which id-based system-org checks won't recognize. */\n  orgId?: string;\n  /** Active org name. Defaults to orgId. */\n  orgName?: string;\n  /** TTL in seconds (default 300). */\n  ttlSeconds?: number;\n  /**\n   * Role the token carries (required — no implicit default). **Pass the LOWEST\n   * role the call actually needs** (`'member'` for read / data-plane calls) so a\n   * leaked service token can't perform admin actions in the target org.\n   * `isAdmin` is derived from this (admin|owner → true).\n   */\n  role: 'owner' | 'admin' | 'member';\n  /**\n   * Optional fine-grained permission claim. Prefer this + `role: 'member'` over a\n   * high role when a call needs ONE specific capability (e.g. `['plugins:write']`\n   * to push a plugin image) — the token then satisfies that permission gate\n   * WITHOUT carrying `isAdmin`, so a leaked token can't perform admin actions.\n   */\n  permissions?: Permission[];\n  /**\n   * Signed claim (`auditCrossOrg: true`) letting an `/audit/events` delivery name\n   * an `affectedOrgId` outside the token's org. Set ONLY by the remote-audit\n   * client, and only when the event's verified inbound principal was a\n   * superadmin or a system-org member — never from call-site input. Means\n   * nothing to any other route.\n   */\n  auditCrossOrg?: boolean;\n}\n\n/**\n * Mint a JWT identifying the calling service. Used for inter-service HTTP calls.\n * The token satisfies `requireAuth` and (when orgId is present) `requireOrganization`.\n * Scope it with `opts.role` — least privilege keeps a leaked token low-value.\n *\n * `opts.serviceName` must be THIS process's own identity (`SERVICE_NAME`): a\n * service holds only its own signing key, so minting a token that names another\n * service throws rather than producing one every peer would reject. That is the\n * one behaviour change #14 forces on callers — see `services/service-keys.ts`.\n */\nexport function signServiceToken(opts: ServiceTokenOptions): string {\n  const role = opts.role;\n  const payload: Omit<JwtPayload, 'sub'> = {\n    username: `${opts.serviceName}-service`,\n    email: `${opts.serviceName}@internal`,\n    principalType: 'service',\n    token_use: 'access',\n    role,\n    isAdmin: role === 'owner' || role === 'admin',\n    type: 'access',\n    organizationId: opts.orgId,\n    organizationName: opts.orgName ?? opts.orgId,\n    // Unique token id on every mint. Combined with the short (300s default) TTL\n    // this gives each service token a distinct identity — the correlation handle\n    // for tracing which mint performed a cross-service action, and the building\n    // block for replay detection (a verifier can track seen jtis). It does NOT\n    // by itself prevent replay within the TTL window.\n    jti: randomUUID(),\n    // Least-privilege capability claim (optional) — lets a member-role token\n    // satisfy a specific permission gate without carrying isAdmin.\n    ...(opts.permissions && opts.permissions.length > 0 ? { permissions: opts.permissions } : {}),\n    ...(opts.auditCrossOrg ? { auditCrossOrg: true as const } : {}),\n  };\n  // `sub`, `iat`/`exp` and the optional issuer/audience that requireAuth\n  // verifies are stamped by the signer, so there is exactly one place that\n  // decides what a service token says.\n  return signServiceJwt(payload as Record<string, unknown>, {\n    serviceName: opts.serviceName,\n    expiresInSeconds: opts.ttlSeconds ?? DEFAULT_SERVICE_TOKEN_TTL_SECONDS,\n    ...issuerAudienceOptions(),\n  });\n}\n\n/** Convenience: returns a `Bearer <token>` header value for fetch/axios calls. */\nexport function getServiceAuthHeader(opts: ServiceTokenOptions): string {\n  return `Bearer ${signServiceToken(opts)}`;\n}\n\n/** True when `req.user` is a service principal (`principalType: 'service'`, minted by `signServiceToken`). */\nexport function isServicePrincipal(req: Request): boolean {\n  return req.user?.principalType === 'service';\n}\n\n/**\n * True when `req.user` is an ORG SERVICE ACCOUNT (`principalType:\n * 'service_account'`) — a non-human principal owned by one org, authenticating\n * with a `pb_sa_…` key exchanged at platform.\n *\n * A service account is NOT an internal service principal: it holds org Roles and\n * is subject to every permission gate a member is. What it can never do is\n * satisfy a HUMAN-presence requirement — step-up (and any later assurance gate)\n * refuses it outright, because there is no person behind it to re-verify.\n */\nexport function isServiceAccountPrincipal(req: Request): boolean {\n  return req.user?.principalType === 'service_account';\n}\n\n/** True when `req.user` is the named internal service (e.g. `'billing'`). */\nexport function isServicePrincipalNamed(req: Request, serviceName: string): boolean {\n  return serviceNameOf(req.user) === serviceName;\n}\n\n/**\n * PRE-auth check: cryptographically verify the request carries a valid, signed\n * SERVICE token (`principalType: 'service'`). Unlike {@link isServicePrincipal}\n * (which reads the already-populated `req.user`), this verifies the bearer token\n * itself, so it is safe to call BEFORE `requireAuth` runs — e.g. the global rate\n * limiter's `skip`, which must not trust the spoofable `x-internal-service`\n * header. Mirrors `requireAuth`'s SERVICE chain exactly (the signer's own key,\n * resolved by `kid`, with the `sub`/signer agreement check and the optional\n * issuer/audience) and returns `false` on any missing/invalid/non-service token\n * — including any platform-signed USER token, whose `kid` is not in the service\n * bundle at all. Stays SYNCHRONOUS, which is why the per-service public keys are\n * distributed as a mounted bundle rather than fetched over HTTP.\n */\nexport function verifyServicePrincipal(req: Request): boolean {\n  const parts = req.headers.authorization?.split(' ');\n  if (!parts || parts.length !== 2 || parts[0] !== 'Bearer') return false;\n  try {\n    const header = decodeJwtHeader(parts[1]);\n    if (!header?.kid || !isServiceKid(header.kid)) return false;\n    const decoded = verifyServiceJwt<JwtPayload>(parts[1], { kid: header.kid, ...issuerAudienceOptions() });\n    if (decoded.type !== 'access' || decoded.principalType !== 'service' || !hasValidIdentityClaims(decoded)) return false;\n    // A denylisted (killed) service must NOT be treated as a trusted principal —\n    // otherwise it keeps the rate-limiter exemption even though requireAuth rejects\n    // it on real routes. Fold the kill-switch into the pre-auth check too.\n    return !isServiceTokenDenied(decoded);\n  } catch {\n    return false;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service-tokens.js","sources":["../../src/middleware/service-tokens.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Service-to-service tokens and service-principal checks.\n */\n\nimport { randomUUID } from 'crypto';\nimport type { Request } from 'express';\nimport { hasValidIdentityClaims, issuerAudienceOptions } from './jwt-verify.js';\nimport { SERVICE_SUBJECT_PREFIX, isServiceKid, signServiceJwt, verifyServiceJwt } from '../services/service-keys.js';\nimport { type JwtPayload } from '../types/common.js';\nimport { type Permission } from '../types/permissions.js';\nimport { decodeJwtHeader } from '../utils/jwk.js';\n// ---------------------------------------------------------------------------\n// Service-to-service tokens\n//\n// Inter-service HTTP calls (billing → message, platform → compliance, etc.)\n// need to satisfy the same `requireAuth` middleware as user requests.\n// `signServiceToken` mints a short-lived ES256 JWT signed with THIS service's\n// OWN key (see `services/service-keys.ts`), carrying `principalType: 'service'`\n// and naming the calling service via `sub: 'service:<name>'`. Gates branch on\n// the claim; the subject names — and since #14 the name is cryptographically\n// bound to the signing key, so it can also be trusted.\n// `requireAuth` accepts these tokens transparently — they pass `decoded.sub`\n// and `decoded.role` checks, and downstream tenancy gates read the org embedded\n// in the token.\n//\n// A service token carries NO admin authority, whatever it claims: the verifier\n// (`verifyServiceJwt` → `withoutServiceAuthorityClaims`) drops `isSuperAdmin`,\n// forces `isAdmin: false` and clamps an `owner`/`admin` role to `member`. What a\n// service may do is decided by its NAME (bound to its key —\n// `requireInternalService`, `isServicePrincipalNamed`) and by the explicit\n// `permissions` claim. Tokens from the out-of-cluster `deploy-bootstrap` signer\n// are refused unless the seam opts in (`requireAuth({ acceptServices })`).\n//\n// Tokens default to 5-minute TTL — long enough to survive a backend hop,\n// short enough that a leaked token is low-value.\n// ---------------------------------------------------------------------------\n\nconst DEFAULT_SERVICE_TOKEN_TTL_SECONDS = 300;\n\n/**\n * Denylist of service NAMES (the `<name>` in `sub: service:<name>`) whose tokens\n * `requireAuth` must reject. Read from `SERVICE_TOKEN_DENYLIST` (comma-separated)\n * at process start, so arming it is a config change + rollout — it cuts off a\n * compromised service WITHOUT rotating any key, and without invalidating every\n * other service's tokens as collateral.\n */\nconst serviceTokenDenylist = new Set(\n  (process.env.SERVICE_TOKEN_DENYLIST || '')\n    .split(',')\n    .map((s) => s.trim())\n    .filter(Boolean),\n);\n\n/**\n * The calling service's name for a SERVICE principal (`principalType: 'service'`),\n * else `undefined`. A user token never yields a name, whatever its `sub` says.\n */\nexport function serviceNameOf(claims: { principalType?: string; sub?: string } | undefined): string | undefined {\n  if (claims?.principalType !== 'service' || typeof claims.sub !== 'string') return undefined;\n  if (!claims.sub.startsWith(SERVICE_SUBJECT_PREFIX)) return undefined;\n  return claims.sub.slice(SERVICE_SUBJECT_PREFIX.length) || undefined;\n}\n\n/** True when the claims are a service principal whose service is on the denylist. */\nexport function isServiceTokenDenied(claims: { principalType?: string; sub?: string }): boolean {\n  if (serviceTokenDenylist.size === 0) return false;\n  const name = serviceNameOf(claims);\n  return name !== undefined && serviceTokenDenylist.has(name);\n}\n\nexport interface ServiceTokenOptions {\n  /** Calling service identifier (e.g. 'billing', 'platform'). Embedded as `sub: service:<name>`. */\n  serviceName: string;\n  /** Active org context for the call. Use the target tenant's org id, or the\n   *  well-known `SYSTEM_ORG_ID` (an ObjectId) for system-wide ops — NOT the string\n   *  'system', which id-based system-org checks won't recognize. */\n  orgId?: string;\n  /** Active org name. Defaults to orgId. */\n  orgName?: string;\n  /** TTL in seconds (default 300). */\n  ttlSeconds?: number;\n  /**\n   * Role the token carries (required — no implicit default). Pass `'member'`:\n   * every verifier clamps a service token's `owner`/`admin` role to `member`\n   * and its `isAdmin` to `false` (`withoutServiceAuthorityClaims`), so a higher\n   * role confers nothing on the receiving side. Grant a capability through\n   * {@link permissions} instead.\n   */\n  role: 'owner' | 'admin' | 'member';\n  /**\n   * Optional fine-grained permission claim. Prefer this + `role: 'member'` over a\n   * high role when a call needs ONE specific capability (e.g. `['plugins:write']`\n   * to push a plugin image) — the token then satisfies that permission gate\n   * WITHOUT carrying `isAdmin`, so a leaked token can't perform admin actions.\n   */\n  permissions?: Permission[];\n  /**\n   * Signed claim (`auditCrossOrg: true`) letting an `/audit/events` delivery name\n   * an `affectedOrgId` outside the token's org. Set ONLY by the remote-audit\n   * client, and only when the event's verified inbound principal was a\n   * superadmin or a system-org member — never from call-site input. Means\n   * nothing to any other route.\n   */\n  auditCrossOrg?: boolean;\n}\n\n/**\n * Mint a JWT identifying the calling service. Used for inter-service HTTP calls.\n * The token satisfies `requireAuth` and (when orgId is present) `requireOrganization`.\n * Scope it with `opts.role` — least privilege keeps a leaked token low-value.\n *\n * `opts.serviceName` must be THIS process's own identity (`SERVICE_NAME`): a\n * service holds only its own signing key, so minting a token that names another\n * service throws rather than producing one every peer would reject. That is the\n * one behaviour change #14 forces on callers — see `services/service-keys.ts`.\n */\nexport function signServiceToken(opts: ServiceTokenOptions): string {\n  const role = opts.role;\n  const payload: Omit<JwtPayload, 'sub'> = {\n    username: `${opts.serviceName}-service`,\n    email: `${opts.serviceName}@internal`,\n    principalType: 'service',\n    token_use: 'access',\n    role,\n    isAdmin: role === 'owner' || role === 'admin',\n    type: 'access',\n    organizationId: opts.orgId,\n    organizationName: opts.orgName ?? opts.orgId,\n    // Unique token id on every mint. Combined with the short (300s default) TTL\n    // this gives each service token a distinct identity — the correlation handle\n    // for tracing which mint performed a cross-service action, and the building\n    // block for replay detection (a verifier can track seen jtis). It does NOT\n    // by itself prevent replay within the TTL window.\n    jti: randomUUID(),\n    // Least-privilege capability claim (optional) — lets a member-role token\n    // satisfy a specific permission gate without carrying isAdmin.\n    ...(opts.permissions && opts.permissions.length > 0 ? { permissions: opts.permissions } : {}),\n    ...(opts.auditCrossOrg ? { auditCrossOrg: true as const } : {}),\n  };\n  // `sub`, `iat`/`exp` and the optional issuer/audience that requireAuth\n  // verifies are stamped by the signer, so there is exactly one place that\n  // decides what a service token says.\n  return signServiceJwt(payload as Record<string, unknown>, {\n    serviceName: opts.serviceName,\n    expiresInSeconds: opts.ttlSeconds ?? DEFAULT_SERVICE_TOKEN_TTL_SECONDS,\n    ...issuerAudienceOptions(),\n  });\n}\n\n/** Convenience: returns a `Bearer <token>` header value for fetch/axios calls. */\nexport function getServiceAuthHeader(opts: ServiceTokenOptions): string {\n  return `Bearer ${signServiceToken(opts)}`;\n}\n\n/** True when `req.user` is a service principal (`principalType: 'service'`, minted by `signServiceToken`). */\nexport function isServicePrincipal(req: Request): boolean {\n  return req.user?.principalType === 'service';\n}\n\n/**\n * True when `req.user` is an ORG SERVICE ACCOUNT (`principalType:\n * 'service_account'`) — a non-human principal owned by one org, authenticating\n * with a `pb_sa_…` key exchanged at platform.\n *\n * A service account is NOT an internal service principal: it holds org Roles and\n * is subject to every permission gate a member is. What it can never do is\n * satisfy a HUMAN-presence requirement — step-up (and any later assurance gate)\n * refuses it outright, because there is no person behind it to re-verify.\n */\nexport function isServiceAccountPrincipal(req: Request): boolean {\n  return req.user?.principalType === 'service_account';\n}\n\n/** True when `req.user` is the named internal service (e.g. `'billing'`). */\nexport function isServicePrincipalNamed(req: Request, serviceName: string): boolean {\n  return serviceNameOf(req.user) === serviceName;\n}\n\n/**\n * PRE-auth check: cryptographically verify the request carries a valid, signed\n * SERVICE token (`principalType: 'service'`). Unlike {@link isServicePrincipal}\n * (which reads the already-populated `req.user`), this verifies the bearer token\n * itself, so it is safe to call BEFORE `requireAuth` runs — e.g. the global rate\n * limiter's `skip`, which must not trust the spoofable `x-internal-service`\n * header. Mirrors `requireAuth`'s SERVICE chain exactly (the signer's own key,\n * resolved by `kid`, with the `sub`/signer agreement check and the optional\n * issuer/audience) and returns `false` on any missing/invalid/non-service token\n * — including any platform-signed USER token, whose `kid` is not in the service\n * bundle at all. Stays SYNCHRONOUS, which is why the per-service public keys are\n * distributed as a mounted bundle rather than fetched over HTTP.\n */\nexport function verifyServicePrincipal(req: Request): boolean {\n  const parts = req.headers.authorization?.split(' ');\n  if (!parts || parts.length !== 2 || parts[0] !== 'Bearer') return false;\n  try {\n    const header = decodeJwtHeader(parts[1]);\n    if (!header?.kid || !isServiceKid(header.kid)) return false;\n    const decoded = verifyServiceJwt<JwtPayload>(parts[1], { kid: header.kid, ...issuerAudienceOptions() });\n    if (decoded.type !== 'access' || decoded.principalType !== 'service' || !hasValidIdentityClaims(decoded)) return false;\n    // A denylisted (killed) service must NOT be treated as a trusted principal —\n    // otherwise it keeps the rate-limiter exemption even though requireAuth rejects\n    // it on real routes. Fold the kill-switch into the pre-auth check too.\n    return !isServiceTokenDenied(decoded);\n  } catch {\n    return false;\n  }\n}\n"]}

package/lib/services/index.d.ts

@@ -10,7 +10,7 @@ export * from './compliance-event-subscriber.js';
 export { type EntityEvent, type EntityEventSubscriber, entityEvents, } from './entity-events.js';
 export { destroySharedHttpAgents, createSafeClient, ResponseTooLargeError, InternalHttpClient, } from './http-client.js';
 export { setPlatformJwksCache, JwksUnavailableError, UnknownKidError, JwksCache, } from './jwks-cache.js';
-export { isServiceKid, serviceIdentity, verifyServiceJwt, } from './service-keys.js';
+export { isServiceKid, OPT_IN_SERVICE_SIGNERS, serviceIdentity, verifyServiceJwt, withoutServiceAuthorityClaims, type ServiceJwtVerifyOptions, } from './service-keys.js';
 export { resetCircuitBreakers, } from './circuit-breaker.js';
 export { createEnvRedisDurableEventBus, type EventSubscription, type DurableEventBus, } from './durable-event-bus.js';
 export { getErrorRetryDecision, } from './retry-strategy.js';

package/lib/services/index.js

@@ -16,7 +16,7 @@ export { setPlatformJwksCache, JwksUnavailableError, UnknownKidError, JwksCache,
 // side that platform's JWT options and the auth middleware need; key MATERIAL
 // handling (`signServiceJwt`, the bundle, the test reset hook) is reachable only
 // by deep import from inside api-core and its testing helpers.
-export { isServiceKid, serviceIdentity, verifyServiceJwt, } from './service-keys.js';
+export { isServiceKid, OPT_IN_SERVICE_SIGNERS, serviceIdentity, verifyServiceJwt, withoutServiceAuthorityClaims, } from './service-keys.js';
 // The breaker is wired by the shared HTTP client; services consume its EFFECT,
 // not the class. Only the operational surface is public.
 export { resetCircuitBreakers, } from './circuit-breaker.js';
@@ -39,4 +39,4 @@ export { verifyPagerDutySignature, onCallInboundConfig, fetchRotaCoverage, parse
 export { sendPagerDutyEvent, pagerDutyConfig, resolveEventsEndpoint, PAGERDUTY_EVENTS_URL, } from './pagerduty.js';
 export { createEcosystemNotifyClient, NOTIFY_EMAIL_PATH, } from './ecosystem-notify-client.js';
 export { fetchOrgAIAccess, fetchOrgAIKey, assertOrgAIEnabled, requireOrgAIEnabled, resetOrgAICache, ORG_AI_ACCESS_PATH, ORG_AI_KEYS_PATH, } from './org-ai-client.js';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sources":["../../src/services/index.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nexport {\n  exchangeApiKey,\n  resetApiKeyExchangeCache,\n  ApiKeyRejectedError,\n  ApiKeyExchangeUnavailableError,\n} from './api-key-exchange.js';\nexport {\n  createCacheService,\n  type RedisCacheClient,\n  type CacheInvalidationMessage,\n  type CacheInvalidationBus,\n  type RedisInvalidationClient,\n  CacheService,\n} from './cache-service.js';\nexport {\n  withLeaderLock,\n  createEnvRedisLock,\n  leaderLockKey,\n  DEFAULT_LEADER_LOCK_TTL_MS,\n  type LockRedis,\n  type LeaderLockRun,\n  type LeaderLockOptions,\n  type LeaderLockAbortReason,\n} from './leader-lock.js';\nexport {\n  sendSystemNotification,\n  SYSTEM_NOTIFY_PATH,\n  type SystemNotification,\n} from './system-notification.js';\nexport {\n  createScheduler,\n  type SchedulerOptions,\n  type Scheduler,\n} from './scheduler.js';\nexport {\n  assessVersionVulns,\n  versionScanFacts,\n  scanFreshness,\n  scanWarnings,\n  lastScannedAt,\n  scanStaleHours,\n  severityOf,\n  maxSeverity,\n  severityAtLeast,\n  VULN_SEVERITIES,\n  setVulnPolicyComplianceClientForTests,\n  type VulnSeverity,\n  type VulnWarning,\n  type ScannedRecord,\n  type VulnConsumptionPolicy,\n  type VulnAcceptance,\n  type VersionScanFacts,\n  type VersionVulnInput,\n  type VersionVulnAssessment,\n} from './version-vuln-policy.js';\nexport {\n  createComplianceClient,\n  type ComplianceCheckResult,\n  type ComplianceViolation,\n} from './compliance-client.js';\nexport {\n  pluginRunsOwnImage,\n  pluginComplianceTags,\n  derivePluginImageCompliance,\n  type PluginComplianceAttributes,\n  PLUGIN_IMAGE_COMPLIANCE_FIELDS,\n  type PluginImageRow,\n} from '../utils/plugin-compliance.js';\nexport * from './compliance-event-subscriber.js';\nexport {\n  type EntityEvent,\n  type EntityEventSubscriber,\n  entityEvents,\n} from './entity-events.js';\nexport {\n  destroySharedHttpAgents,\n  createSafeClient,\n  ResponseTooLargeError,\n  InternalHttpClient,\n} from './http-client.js';\nexport {\n  setPlatformJwksCache,\n  JwksUnavailableError,\n  UnknownKidError,\n  JwksCache,\n} from './jwks-cache.js';\n// Service-key internals stay internal. The package surface is the verify/inspect\n// side that platform's JWT options and the auth middleware need; key MATERIAL\n// handling (`signServiceJwt`, the bundle, the test reset hook) is reachable only\n// by deep import from inside api-core and its testing helpers.\nexport {\n  isServiceKid,\n  serviceIdentity,\n  verifyServiceJwt,\n} from './service-keys.js';\n// The breaker is wired by the shared HTTP client; services consume its EFFECT,\n// not the class. Only the operational surface is public.\nexport {\n  resetCircuitBreakers,\n} from './circuit-breaker.js';\nexport {\n  createEnvRedisDurableEventBus,\n  type EventSubscription,\n  type DurableEventBus,\n} from './durable-event-bus.js';\nexport {\n  getErrorRetryDecision,\n} from './retry-strategy.js';\nexport type {\n  RetryConfig,\n} from './retry-strategy.js';\nexport {\n  nextBackoffMs,\n  retryForever,\n} from './retry-forever.js';\nexport {\n  getQuotaServiceAuthHeader,\n  createQuotaService,\n  incrementQuota,\n  reserveQuota,\n  sendQuotaReserveDenied,\n  decrementQuota,\n  meteredQuotaTypeFor,\n  callQuotaExemption,\n  QUOTA_CHECK_TIMEOUT_MS,\n  quotaAttributionFromRequest,\n  type AiKeySource,\n  type AiLimitCode,\n  type CallQuotaExemption,\n  type QuotaReserveResult,\n  type QuotaTokenUsage,\n  type QuotaService,\n  type QuotaUsageAttribution,\n} from './quota.js';\nexport {\n  aiCallWeight,\n  parseAiModelWeights,\n  MAX_AI_CALL_WEIGHT,\n} from './ai-call-weight.js';\nexport {\n  QuotaIncrementBatcher,\n  flushQuotaIncrements,\n  QUOTA_INCREMENT_FLUSH_MS,\n  QUOTA_INCREMENT_BUFFER_MAX,\n  MAX_GROUPS_PER_INCREMENT,\n  type MeteredIncrementGroup,\n} from './quota-increment-batcher.js';\nexport {\n  createRemoteAuditClient,\n  wireAuthzDenialAuditor,\n  recordAudit,\n  type RemoteAuditEvent,\n  type RemoteAuditWireEvent,\n  type RemoteAuditClient,\n} from './remote-audit-client.js';\nexport {\n  runWithAuditContext,\n  currentAuditContext,\n  auditContextFromRequest,\n  auditAuthBlock,\n  sanitizeCorrelationId,\n  sanitizeUserAgent,\n  AUDIT_CORRELATION_HEADERS,\n  type AuditContext,\n  type AuditCorrelation,\n  type AuditJobContext,\n  type AuditAuthBlock,\n} from './audit-context.js';\nexport {\n  auditSpoolKey,\n  createEnvRedisAuditSpool,\n  type AuditSpool,\n} from './audit-spool.js';\nexport {\n  resolveRedisConnection,\n  describeRedisConnection,\n  createRedisClient,\n  createEnvRedisClient,\n  createRedisReadyGate,\n  incrWindow,\n  RedisConfigError,\n  type RedisEvalClient,\n} from './env-redis.js';\nexport {\n  createRedisTokenRevocationStore,\n  createEnvRedisTokenRevocationStore,\n  publishTokenRevocation,\n  publishSessionRevocation,\n  publishCredentialRevocation,\n} from './token-revocation.js';\nexport {\n  createMemorySseTicketStore,\n  createEnvSseTicketStore,\n  envSseTicketCaps,\n  type EnvSseTicketStoreConfig,\n  type SseTicketStore,\n  type SseTicketStoreConfig,\n} from './sse-ticket-store.js';\nexport {\n  wireServiceSecurity,\n} from './service-boot.js';\nexport {\n  createWebhookChannel,\n  createEmailChannel,\n  createChannelRegistry,\n  type NotificationPriority,\n  type NotificationMessage,\n  type ChannelTarget,\n  type DeliveryResult,\n  type NotificationChannel,\n} from './notification-channels.js';\nexport {\n  alertDeliveryConfig,\n  canDeliverAnywhere,\n  deadmanConfig,\n  reportAlertDeliveryPosture,\n  slackAlertsConfig,\n  startDeadmanHeartbeat,\n  stopDeadmanHeartbeat,\n  type DeadmanConfig,\n  type AlertDeliveryConfig,\n  type SlackAlertsConfig,\n} from './alert-delivery.js';\nexport {\n  verifyPagerDutySignature,\n  onCallInboundConfig,\n  fetchRotaCoverage,\n  parseOnCallWebhook,\n  ackLatencySeconds,\n  PAGERDUTY_API_URL,\n  type OnCallInboundConfig,\n  type OnCallWebhookEvent,\n  type OnCallWebhookEventType,\n  type RotaCoverage,\n} from './pagerduty-inbound.js';\nexport {\n  sendPagerDutyEvent,\n  pagerDutyConfig,\n  resolveEventsEndpoint,\n  PAGERDUTY_EVENTS_URL,\n  type OnCallProvider,\n  type PagerDutyAction,\n  type PagerDutyConfig,\n  type PagerDutyEvent,\n  type PagerDutyResult,\n  type PagerDutySeverity,\n} from './pagerduty.js';\nexport {\n  createEcosystemNotifyClient,\n  NOTIFY_EMAIL_PATH,\n  type EcosystemNotifyClient,\n} from './ecosystem-notify-client.js';\nexport {\n  fetchOrgAIAccess,\n  fetchOrgAIKey,\n  assertOrgAIEnabled,\n  requireOrgAIEnabled,\n  resetOrgAICache,\n  ORG_AI_ACCESS_PATH,\n  ORG_AI_KEYS_PATH,\n  type OrgAIAccess,\n} from './org-ai-client.js';\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EACL,cAAc,EACd,wBAAwB,EACxB,mBAAmB,EACnB,8BAA8B,GAC/B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,kBAAkB,EAKlB,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,aAAa,EACb,0BAA0B,GAK3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,sBAAsB,EACtB,kBAAkB,GAEnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,eAAe,GAGhB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,aAAa,EACb,YAAY,EACZ,aAAa,EACb,cAAc,EACd,UAAU,EACV,WAAW,EACX,eAAe,EACf,eAAe,EACf,qCAAqC,GAStC,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,sBAAsB,GAGvB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,2BAA2B,EAE3B,8BAA8B,GAE/B,MAAM,+BAA+B,CAAC;AACvC,cAAc,kCAAkC,CAAC;AACjD,OAAO,EAGL,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,eAAe,EACf,SAAS,GACV,MAAM,iBAAiB,CAAC;AACzB,iFAAiF;AACjF,8EAA8E;AAC9E,iFAAiF;AACjF,+DAA+D;AAC/D,OAAO,EACL,YAAY,EACZ,sBAAsB,EACtB,eAAe,EACf,gBAAgB,EAChB,6BAA6B,GAE9B,MAAM,mBAAmB,CAAC;AAC3B,+EAA+E;AAC/E,yDAAyD;AACzD,OAAO,EACL,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,6BAA6B,GAG9B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,qBAAqB,GACtB,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EACL,aAAa,EACb,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,yBAAyB,EACzB,kBAAkB,EAClB,cAAc,EACd,YAAY,EACZ,sBAAsB,EACtB,cAAc,EACd,mBAAmB,EACnB,kBAAkB,EAClB,sBAAsB,EACtB,2BAA2B,GAQ5B,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,YAAY,EACZ,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,qBAAqB,EACrB,oBAAoB,EACpB,wBAAwB,EACxB,0BAA0B,EAC1B,wBAAwB,GAEzB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,uBAAuB,EACvB,sBAAsB,EACtB,WAAW,GAIZ,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,uBAAuB,EACvB,cAAc,EACd,qBAAqB,EACrB,iBAAiB,EACjB,yBAAyB,GAK1B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,aAAa,EACb,wBAAwB,GAEzB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,UAAU,EACV,gBAAgB,GAEjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,+BAA+B,EAC/B,kCAAkC,EAClC,sBAAsB,EACtB,wBAAwB,EACxB,2BAA2B,GAC5B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,0BAA0B,EAC1B,uBAAuB,EACvB,gBAAgB,GAIjB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,mBAAmB,GACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,qBAAqB,GAMtB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,aAAa,EACb,0BAA0B,EAC1B,iBAAiB,EACjB,qBAAqB,EACrB,oBAAoB,GAIrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,wBAAwB,EACxB,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,GAKlB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,oBAAoB,GAOrB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,2BAA2B,EAC3B,iBAAiB,GAElB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,gBAAgB,EAChB,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,eAAe,EACf,kBAAkB,EAClB,gBAAgB,GAEjB,MAAM,oBAAoB,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nexport {\n  exchangeApiKey,\n  resetApiKeyExchangeCache,\n  ApiKeyRejectedError,\n  ApiKeyExchangeUnavailableError,\n} from './api-key-exchange.js';\nexport {\n  createCacheService,\n  type RedisCacheClient,\n  type CacheInvalidationMessage,\n  type CacheInvalidationBus,\n  type RedisInvalidationClient,\n  CacheService,\n} from './cache-service.js';\nexport {\n  withLeaderLock,\n  createEnvRedisLock,\n  leaderLockKey,\n  DEFAULT_LEADER_LOCK_TTL_MS,\n  type LockRedis,\n  type LeaderLockRun,\n  type LeaderLockOptions,\n  type LeaderLockAbortReason,\n} from './leader-lock.js';\nexport {\n  sendSystemNotification,\n  SYSTEM_NOTIFY_PATH,\n  type SystemNotification,\n} from './system-notification.js';\nexport {\n  createScheduler,\n  type SchedulerOptions,\n  type Scheduler,\n} from './scheduler.js';\nexport {\n  assessVersionVulns,\n  versionScanFacts,\n  scanFreshness,\n  scanWarnings,\n  lastScannedAt,\n  scanStaleHours,\n  severityOf,\n  maxSeverity,\n  severityAtLeast,\n  VULN_SEVERITIES,\n  setVulnPolicyComplianceClientForTests,\n  type VulnSeverity,\n  type VulnWarning,\n  type ScannedRecord,\n  type VulnConsumptionPolicy,\n  type VulnAcceptance,\n  type VersionScanFacts,\n  type VersionVulnInput,\n  type VersionVulnAssessment,\n} from './version-vuln-policy.js';\nexport {\n  createComplianceClient,\n  type ComplianceCheckResult,\n  type ComplianceViolation,\n} from './compliance-client.js';\nexport {\n  pluginRunsOwnImage,\n  pluginComplianceTags,\n  derivePluginImageCompliance,\n  type PluginComplianceAttributes,\n  PLUGIN_IMAGE_COMPLIANCE_FIELDS,\n  type PluginImageRow,\n} from '../utils/plugin-compliance.js';\nexport * from './compliance-event-subscriber.js';\nexport {\n  type EntityEvent,\n  type EntityEventSubscriber,\n  entityEvents,\n} from './entity-events.js';\nexport {\n  destroySharedHttpAgents,\n  createSafeClient,\n  ResponseTooLargeError,\n  InternalHttpClient,\n} from './http-client.js';\nexport {\n  setPlatformJwksCache,\n  JwksUnavailableError,\n  UnknownKidError,\n  JwksCache,\n} from './jwks-cache.js';\n// Service-key internals stay internal. The package surface is the verify/inspect\n// side that platform's JWT options and the auth middleware need; key MATERIAL\n// handling (`signServiceJwt`, the bundle, the test reset hook) is reachable only\n// by deep import from inside api-core and its testing helpers.\nexport {\n  isServiceKid,\n  OPT_IN_SERVICE_SIGNERS,\n  serviceIdentity,\n  verifyServiceJwt,\n  withoutServiceAuthorityClaims,\n  type ServiceJwtVerifyOptions,\n} from './service-keys.js';\n// The breaker is wired by the shared HTTP client; services consume its EFFECT,\n// not the class. Only the operational surface is public.\nexport {\n  resetCircuitBreakers,\n} from './circuit-breaker.js';\nexport {\n  createEnvRedisDurableEventBus,\n  type EventSubscription,\n  type DurableEventBus,\n} from './durable-event-bus.js';\nexport {\n  getErrorRetryDecision,\n} from './retry-strategy.js';\nexport type {\n  RetryConfig,\n} from './retry-strategy.js';\nexport {\n  nextBackoffMs,\n  retryForever,\n} from './retry-forever.js';\nexport {\n  getQuotaServiceAuthHeader,\n  createQuotaService,\n  incrementQuota,\n  reserveQuota,\n  sendQuotaReserveDenied,\n  decrementQuota,\n  meteredQuotaTypeFor,\n  callQuotaExemption,\n  QUOTA_CHECK_TIMEOUT_MS,\n  quotaAttributionFromRequest,\n  type AiKeySource,\n  type AiLimitCode,\n  type CallQuotaExemption,\n  type QuotaReserveResult,\n  type QuotaTokenUsage,\n  type QuotaService,\n  type QuotaUsageAttribution,\n} from './quota.js';\nexport {\n  aiCallWeight,\n  parseAiModelWeights,\n  MAX_AI_CALL_WEIGHT,\n} from './ai-call-weight.js';\nexport {\n  QuotaIncrementBatcher,\n  flushQuotaIncrements,\n  QUOTA_INCREMENT_FLUSH_MS,\n  QUOTA_INCREMENT_BUFFER_MAX,\n  MAX_GROUPS_PER_INCREMENT,\n  type MeteredIncrementGroup,\n} from './quota-increment-batcher.js';\nexport {\n  createRemoteAuditClient,\n  wireAuthzDenialAuditor,\n  recordAudit,\n  type RemoteAuditEvent,\n  type RemoteAuditWireEvent,\n  type RemoteAuditClient,\n} from './remote-audit-client.js';\nexport {\n  runWithAuditContext,\n  currentAuditContext,\n  auditContextFromRequest,\n  auditAuthBlock,\n  sanitizeCorrelationId,\n  sanitizeUserAgent,\n  AUDIT_CORRELATION_HEADERS,\n  type AuditContext,\n  type AuditCorrelation,\n  type AuditJobContext,\n  type AuditAuthBlock,\n} from './audit-context.js';\nexport {\n  auditSpoolKey,\n  createEnvRedisAuditSpool,\n  type AuditSpool,\n} from './audit-spool.js';\nexport {\n  resolveRedisConnection,\n  describeRedisConnection,\n  createRedisClient,\n  createEnvRedisClient,\n  createRedisReadyGate,\n  incrWindow,\n  RedisConfigError,\n  type RedisEvalClient,\n} from './env-redis.js';\nexport {\n  createRedisTokenRevocationStore,\n  createEnvRedisTokenRevocationStore,\n  publishTokenRevocation,\n  publishSessionRevocation,\n  publishCredentialRevocation,\n} from './token-revocation.js';\nexport {\n  createMemorySseTicketStore,\n  createEnvSseTicketStore,\n  envSseTicketCaps,\n  type EnvSseTicketStoreConfig,\n  type SseTicketStore,\n  type SseTicketStoreConfig,\n} from './sse-ticket-store.js';\nexport {\n  wireServiceSecurity,\n} from './service-boot.js';\nexport {\n  createWebhookChannel,\n  createEmailChannel,\n  createChannelRegistry,\n  type NotificationPriority,\n  type NotificationMessage,\n  type ChannelTarget,\n  type DeliveryResult,\n  type NotificationChannel,\n} from './notification-channels.js';\nexport {\n  alertDeliveryConfig,\n  canDeliverAnywhere,\n  deadmanConfig,\n  reportAlertDeliveryPosture,\n  slackAlertsConfig,\n  startDeadmanHeartbeat,\n  stopDeadmanHeartbeat,\n  type DeadmanConfig,\n  type AlertDeliveryConfig,\n  type SlackAlertsConfig,\n} from './alert-delivery.js';\nexport {\n  verifyPagerDutySignature,\n  onCallInboundConfig,\n  fetchRotaCoverage,\n  parseOnCallWebhook,\n  ackLatencySeconds,\n  PAGERDUTY_API_URL,\n  type OnCallInboundConfig,\n  type OnCallWebhookEvent,\n  type OnCallWebhookEventType,\n  type RotaCoverage,\n} from './pagerduty-inbound.js';\nexport {\n  sendPagerDutyEvent,\n  pagerDutyConfig,\n  resolveEventsEndpoint,\n  PAGERDUTY_EVENTS_URL,\n  type OnCallProvider,\n  type PagerDutyAction,\n  type PagerDutyConfig,\n  type PagerDutyEvent,\n  type PagerDutyResult,\n  type PagerDutySeverity,\n} from './pagerduty.js';\nexport {\n  createEcosystemNotifyClient,\n  NOTIFY_EMAIL_PATH,\n  type EcosystemNotifyClient,\n} from './ecosystem-notify-client.js';\nexport {\n  fetchOrgAIAccess,\n  fetchOrgAIKey,\n  assertOrgAIEnabled,\n  requireOrgAIEnabled,\n  resetOrgAICache,\n  ORG_AI_ACCESS_PATH,\n  ORG_AI_KEYS_PATH,\n  type OrgAIAccess,\n} from './org-ai-client.js';\n"]}

package/lib/services/service-keys.d.ts

@@ -47,6 +47,55 @@ export declare function signServiceJwt(claims: Record<string, unknown>, options:
     issuer?: string;
     audience?: string;
 }): string;
+/**
+ * Signers whose key is published in the bundle but whose PRIVATE half lives
+ * OUTSIDE the cluster — today only `deploy-bootstrap`, which the deploy scripts
+ * hold on the operator / CI host (`certs/service-keys/deploy-bootstrap.key`)
+ * for the registry base-image push.
+ *
+ * Because the public bundle is mounted into EVERY service, a token from such a
+ * signer would otherwise verify everywhere. So {@link verifyServiceJwt} refuses
+ * these signers unless the call site names them in `acceptServices` — trust in
+ * an out-of-cluster key is opted into per verification seam, never inherited
+ * from the bundle. The seams that opt in today:
+ *
+ *  - api/image-registry `auth-resolver.ts` (the `/token` mint for the
+ *    `library/*` base-image push), via `verifyBearerToken(token, { acceptServices })`.
+ *
+ * A route opts in with `requireAuth({ acceptServices: ['deploy-bootstrap'] })`.
+ */
+export declare const OPT_IN_SERVICE_SIGNERS: readonly string[];
+/** Options every service-token verification takes. */
+export interface ServiceJwtVerifyOptions {
+    kid: string;
+    issuer?: string;
+    audience?: string;
+    /**
+     * {@link OPT_IN_SERVICE_SIGNERS} this call site trusts. Any opt-in signer
+     * NOT listed is refused as an invalid token (401 at `requireAuth`). Naming an
+     * ordinary in-cluster service here is a no-op — those are always accepted.
+     */
+    acceptServices?: readonly string[];
+}
+/**
+ * The claims of a verified service token with every AUTHORITY claim a service
+ * may not assert about itself removed. A service principal's authority is its
+ * NAME (bound to its key — `requireInternalService`, `isServicePrincipalNamed`)
+ * plus the explicit least-privilege `permissions` claim, and nothing else:
+ *
+ *  - `isSuperAdmin` is dropped — superadmin is a property of a PERSON, minted
+ *    only by platform's user signer; a service key cannot confer it;
+ *  - `isAdmin` is forced `false` and an `owner`/`admin` `role` is clamped to
+ *    `member` — org admin-ness is likewise a person's membership, and every
+ *    org-admin predicate (`isOrgAdmin`, `isAdmin === true`) reads one of these.
+ *
+ * Fail-safe by construction: a gate that wrongly relied on a service token's
+ * admin claim now refuses (403), it never grants more. Applied inside
+ * {@link verifyServiceJwt}, so EVERY chain that accepts a service token —
+ * api-core `requireAuth` / `verifyServicePrincipal`, platform's own verifier,
+ * image-registry's `/token` resolver — sees the same reduced claim set.
+ */
+export declare function withoutServiceAuthorityClaims<T>(claims: T): T;
 /**
  * Verify an internal service token, SYNCHRONOUSLY, and return its claims.
  *
@@ -55,16 +104,19 @@ export declare function signServiceJwt(claims: Record<string, unknown>, options:
  * be impersonated by any other service — not even one that holds a valid key of
  * its own — a guarantee no shared secret can give.
  *
+ * Two further rules, both fail-closed:
+ *  - an {@link OPT_IN_SERVICE_SIGNERS opt-in signer} (`deploy-bootstrap`) is
+ *    refused unless `options.acceptServices` names it;
+ *  - the returned claims never carry superadmin or org-admin authority
+ *    ({@link withoutServiceAuthorityClaims}).
+ *
  * @throws {jwt.JsonWebTokenError} unknown `kid`, wrong algorithm, bad
- *         signature, expired, or a `sub` that disagrees with the signing key.
+ *         signature, expired, a `sub` that disagrees with the signing key, or an
+ *         opt-in signer this call site did not accept.
  * @throws {ServiceKeyError} no verification bundle could be read at all — the
  *         token's validity is UNKNOWN and the caller must not treat it as valid.
  */
-export declare function verifyServiceJwt<T = Record<string, unknown>>(token: string, options: {
-    kid: string;
-    issuer?: string;
-    audience?: string;
-}): T;
+export declare function verifyServiceJwt<T = Record<string, unknown>>(token: string, options: ServiceJwtVerifyOptions): T;
 /**
  * True while this service still publishes more than one verification key — i.e.
  * a signing-key rotation is open and the retiring key is still trusted. Feeds