@pipeline-builder/api-core 4.1.12 → 4.1.14

package/lib/middleware/permission-gates.js

@@ -0,0 +1,260 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { tagRouteGate } from './route-table.js';
+import { HttpStatus } from '../constants/http-status.js';
+import { serviceIdentity } from '../services/service-keys.js';
+import { ErrorCode } from '../types/error-codes.js';
+import { hasPermission } from '../types/permissions.js';
+import { emitCounter } from '../utils/metric-emitter.js';
+import { sendError } from '../utils/response.js';
+import { isServicePrincipal, serviceNameOf } from './service-tokens.js';
+import { createLogger } from '../utils/logger.js';
+const logger = createLogger('auth-middleware');
+/**
+ * Whether the request's user holds `permission`. Superadmins implicitly hold
+ * every permission. Reads the resolved `permissions` claim (set at token issue,
+ * or re-derived per request by the platform).
+ */
+export function userHasPermission(req, permission) {
+    return hasPermission(req.user?.permissions, permission, req.user?.isSuperAdmin);
+}
+/**
+ * Optional sink for denied-authorization events. Left unset by default so
+ * api-core stays decoupled from any audit transport — a service registers one
+ * at boot (typically forwarding to its `RemoteAuditClient` as an
+ * `authz.denied` event, or, on platform, to the local `audit()` helper).
+ * MUST be best-effort: it is invoked inside the request path, so it must never
+ * throw or block (the gate wraps the call in try/catch regardless).
+ */
+let authzDenialAuditor;
+/**
+ * Register (or clear, with `undefined`) the process-wide authorization-denial
+ * auditor. Idempotent; the last registration wins.
+ */
+export function setAuthzDenialAuditor(fn) {
+    authzDenialAuditor = fn;
+}
+/**
+ * Emit a denial event, best-effort. Only fires for state-changing (non-GET,
+ * non-HEAD/OPTIONS) requests — a rejected GET is low-signal probing noise and
+ * would amplify audit volume under a scan. Never throws.
+ *
+ * The permission gates here call it themselves. Export it for data-driven checks
+ * a route makes inline (cross-org access, service-only endpoints), so those 403s
+ * reach the same `authz.denied` trail. `required` names what was missing.
+ */
+export function recordAuthzDenial(req, required) {
+    const auditor = authzDenialAuditor;
+    if (!auditor)
+        return;
+    const method = req.method.toUpperCase();
+    if (method === 'GET' || method === 'HEAD' || method === 'OPTIONS')
+        return;
+    try {
+        auditor({
+            actorId: req.user?.sub,
+            actorEmail: req.user?.email,
+            orgId: req.user?.organizationId,
+            method,
+            // Strip the query string — a denied request may carry a token/secret as a
+            // query param, and this path is persisted verbatim into the audit log.
+            path: (req.originalUrl || req.url).split('?')[0],
+            required,
+        });
+    }
+    catch {
+        // Best-effort — a broken auditor must never break the auth gate.
+    }
+}
+/** The shared gate preamble: answer 401 and return false when unauthenticated. */
+function requireUser(req, res) {
+    if (req.user)
+        return true;
+    sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);
+    return false;
+}
+/** Audit + answer a permission refusal (`missing` defaults to every required permission). */
+function denyPermission(req, res, permissions, mode, missing = permissions) {
+    recordAuthzDenial(req, permissions.join(` ${mode} `));
+    sendError(res, HttpStatus.FORBIDDEN, `Missing required permission: ${missing.join(` ${mode} `)}`, ErrorCode.INSUFFICIENT_PERMISSIONS);
+}
+/**
+ * Requires that the user hold AT LEAST ONE of the given permissions (or be a
+ * superadmin). Use after requireAuth. Mirrors `requireRole`'s any-of semantics;
+ * pass a single permission for a specific action, or several when any one of
+ * them should grant access.
+ */
+export function requirePermission(...permissions) {
+    return tagRouteGate((req, res, next) => {
+        if (!requireUser(req, res))
+            return;
+        // userHasPermission → hasPermission already grants superadmins every
+        // permission, so this single check covers both the superadmin bypass and
+        // the any-of membership test without re-inlining either.
+        if (permissions.some((p) => userHasPermission(req, p)))
+            return next();
+        denyPermission(req, res, permissions, 'or');
+    }, { kind: 'permission', mode: 'any', permissions });
+}
+/**
+ * Requires that the user hold EVERY one of the given permissions (or be a
+ * superadmin) — the AND counterpart to `requirePermission`'s any-of. Use for a
+ * sensitive action that legitimately demands two distinct capabilities at once
+ * (e.g. a cross-surface operation), so the guarantee is explicit rather than
+ * approximated by chaining two `requirePermission` gates. Superadmins bypass
+ * (they implicitly hold every permission).
+ */
+export function requireAllPermissions(...permissions) {
+    return tagRouteGate((req, res, next) => {
+        if (!requireUser(req, res))
+            return;
+        const missing = permissions.filter((p) => !userHasPermission(req, p));
+        if (missing.length === 0)
+            return next();
+        denyPermission(req, res, permissions, 'and', missing);
+    }, { kind: 'permission', mode: 'all', permissions });
+}
+/**
+ * Like {@link requirePermission} (any-of) but ALSO admits an internal service
+ * principal (`principalType: 'service'`). For READ endpoints that BOTH
+ * interactive users — who must hold one of the `:read` capabilities — AND
+ * service-to-service callers legitimately hit; service tokens carry no
+ * permission claims (they're least-privilege `role:member`), so a plain
+ * `requirePermission` would wrongly 403 them. Superadmins pass via
+ * `userHasPermission`'s implicit-all. Use only where a service caller is a known,
+ * intended consumer of the route (verify the callers); prefer plain
+ * `requirePermission` for purely user-facing reads.
+ */
+export function requirePermissionOrService(...permissions) {
+    return tagRouteGate((req, res, next) => {
+        if (!requireUser(req, res))
+            return;
+        if (isServicePrincipal(req) || permissions.some((p) => userHasPermission(req, p)))
+            return next();
+        denyPermission(req, res, permissions, 'or');
+    }, { kind: 'permission', mode: 'any', permissions, allowService: true });
+}
+/**
+ * Gate an endpoint to internal service-to-service callers only (a
+ * `principalType: 'service'` principal minted via {@link signServiceToken} / `getServiceAuthHeader`).
+ * Rejects any user token. For NON-user-facing endpoints — entity-event ingest,
+ * auto-subscribe, and similar peer-service hooks — that a browser must never
+ * reach. Compose after `requireAuth` so `req.user` is populated.
+ */
+export function requireServicePrincipal(req, res, next) {
+    if (!isServicePrincipal(req)) {
+        // 403 (not 400) — this is an authorization refusal; status must match the
+        // INSUFFICIENT_PERMISSIONS code and the sibling gates (requirePermission, etc.).
+        return sendError(res, HttpStatus.FORBIDDEN, 'Internal service calls only', ErrorCode.INSUFFICIENT_PERMISSIONS);
+    }
+    next();
+}
+tagRouteGate(requireServicePrincipal, { kind: 'servicePrincipal' });
+/**
+ * THE gate for an INTERNAL route — the one every `/internal/*` path, the
+ * quota usage counters, the entity-event ingest and the audit ingest go through.
+ *
+ * Two rules, both fail-closed:
+ *
+ *  1. **No user token, ever.** Not a member's, not a superadmin's, not a
+ *     service-account key's. An internal route is a peer-service API surface, so
+ *     "a sufficiently privileged human" is not an acceptable caller — that
+ *     equivalence is exactly how a browser-reachable path becomes a tenant
+ *     boundary bug. `requireServicePrincipal` already refused users; this also
+ *     closes the `|| isSystemAdmin(req)` escape hatches that had grown around
+ *     the individual internal routes.
+ *  2. **Only the NAMED callers.** `callers` lists the services that legitimately
+ *     call this route, and the name is cryptographically bound to the signing
+ *     key (`services/service-keys.ts`), so this is an identity check rather than
+ *     a claim check. It is the same allow-list the mesh policy names, at the
+ *     layer that also holds in docker compose, where there is no mesh at all —
+ *     the Istio `AuthorizationPolicy` is defence in depth on top, never the
+ *     enforcement.
+ *
+ * Compose after `requireAuth` so `req.user` is populated. Refusals are counted
+ * (`internal_route_refused_total`) and audited through the shared `authz.denied`
+ * sink.
+ */
+export function requireInternalService(options) {
+    const allowed = new Set(options.callers);
+    return tagRouteGate((req, res, next) => {
+        const refuse = (reason) => {
+            emitCounter('internal_route_refused_total', {
+                service: serviceIdentity(),
+                route: req.route?.path ? `${req.method} ${req.baseUrl}${req.route.path}` : `${req.method} ${(req.originalUrl || req.url).split('?')[0]}`,
+                reason,
+                caller: serviceNameOf(req.user) ?? 'none',
+            });
+            recordAuthzDenial(req, `internal-service (${options.callers.join(', ')})`);
+            if (reason === 'unauthenticated') {
+                return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);
+            }
+            logger.warn('Refused an internal route', { reason, path: (req.originalUrl || req.url).split('?')[0], caller: serviceNameOf(req.user) });
+            return sendError(res, HttpStatus.FORBIDDEN, 'Internal service calls only', ErrorCode.INSUFFICIENT_PERMISSIONS);
+        };
+        if (!req.user)
+            return refuse('unauthenticated');
+        if (!isServicePrincipal(req))
+            return refuse('user_token');
+        const caller = serviceNameOf(req.user);
+        if (!caller || !allowed.has(caller))
+            return refuse('wrong_caller');
+        next();
+    }, { kind: 'servicePrincipal' }, { kind: 'internalService', callers: [...options.callers] });
+}
+/**
+ * Check if the request is from a system admin.
+ *
+ * Authority is granted solely by the user-level `isSuperAdmin` flag carried
+ * in the JWT — never by membership in the well-known 'system' org, which would
+ * conflate a Pipeline Builder operator with a customer tenant and let any
+ * write that created a 'system'-named org quietly grant cross-org authority. The `system` org still exists as a *content holder* for shared
+ * sample data; it confers no privilege.
+ */
+export function isSystemAdmin(req) {
+    return req.user?.isSuperAdmin === true;
+}
+/**
+ * Whether the request's token carries a specific capability `scope` (e.g.
+ * `'reporting:ingest'`). Used to gate endpoints that accept a narrow machine
+ * identity — a normal interactive user token has no `scope` and returns false.
+ */
+export function hasScope(req, scope) {
+    return req.user?.scope === scope;
+}
+/** Requires a system admin — granted solely by the `isSuperAdmin` token claim.
+ *  Use after requireAuth. */
+export function requireSystemAdmin(req, res, next) {
+    if (!isSystemAdmin(req)) {
+        recordAuthzDenial(req, 'system-admin');
+        return sendError(res, HttpStatus.FORBIDDEN, 'Access denied. Only system administrators can perform this action.', ErrorCode.INSUFFICIENT_PERMISSIONS);
+    }
+    next();
+}
+tagRouteGate(requireSystemAdmin, { kind: 'systemAdmin' });
+/**
+ * Require a specific feature flag. Use after requireAuth.
+ * Checks the `features` array in the JWT payload (set at token issuance).
+ * Sysadmins (isSuperAdmin) bypass — they always have every feature.
+ */
+export function requireFeature(feature) {
+    return tagRouteGate((req, res, next) => {
+        if (!requireUser(req, res))
+            return;
+        // Sysadmins get all features; the `features` array on their token is
+        // populated with every flag at issuance time but the bypass here keeps
+        // the rule explicit and survives a token issued before a new feature
+        // flag was added.
+        if (req.user.isSuperAdmin === true)
+            return next();
+        if (!req.user.features?.includes(feature)) {
+            // Route feature-gate denials through the same audit sink as
+            // requirePermission / requireSystemAdmin so a probe for an
+            // unentitled capability leaves a trail (state-changing methods only).
+            recordAuthzDenial(req, `feature:${feature}`);
+            return sendError(res, HttpStatus.FORBIDDEN, `This feature requires a higher plan (${feature})`, ErrorCode.INSUFFICIENT_PERMISSIONS);
+        }
+        next();
+    }, { kind: 'feature', feature });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permission-gates.js","sourceRoot":"","sources":["../../src/middleware/permission-gates.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Authorization gates — permissions, system admin, features — and the\n * `authz.denied` audit sink they report refusals to.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport { tagRouteGate } from './route-table.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport { serviceIdentity } from '../services/service-keys.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { type Permission, hasPermission } from '../types/permissions.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { sendError } from '../utils/response.js';\nimport { isServicePrincipal, serviceNameOf } from './service-tokens.js';\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('auth-middleware');\n/**\n * Whether the request's user holds `permission`. Superadmins implicitly hold\n * every permission. Reads the resolved `permissions` claim (set at token issue,\n * or re-derived per request by the platform).\n */\nexport function userHasPermission(req: Request, permission: Permission): boolean {\n  return hasPermission(req.user?.permissions, permission, req.user?.isSuperAdmin);\n}\n\n/**\n * Context passed to a registered authorization-denial auditor when a\n * state-changing request is rejected by `requirePermission` /\n * `requireSystemAdmin`.\n */\nexport interface AuthzDenialInfo {\n  /** The denied user's id (`sub`), if authenticated. */\n  actorId?: string;\n  actorEmail?: string;\n  /** The user's active org at denial time. */\n  orgId?: string;\n  /** HTTP method + path of the rejected request. */\n  method: string;\n  path: string;\n  /** What was required: the missing permission(s), or 'system-admin'. */\n  required: string;\n}\n\n/**\n * Optional sink for denied-authorization events. Left unset by default so\n * api-core stays decoupled from any audit transport — a service registers one\n * at boot (typically forwarding to its `RemoteAuditClient` as an\n * `authz.denied` event, or, on platform, to the local `audit()` helper).\n * MUST be best-effort: it is invoked inside the request path, so it must never\n * throw or block (the gate wraps the call in try/catch regardless).\n */\nlet authzDenialAuditor: ((info: AuthzDenialInfo) => void) | undefined;\n\n/**\n * Register (or clear, with `undefined`) the process-wide authorization-denial\n * auditor. Idempotent; the last registration wins.\n */\nexport function setAuthzDenialAuditor(fn: ((info: AuthzDenialInfo) => void) | undefined): void {\n  authzDenialAuditor = fn;\n}\n\n/**\n * Emit a denial event, best-effort. Only fires for state-changing (non-GET,\n * non-HEAD/OPTIONS) requests — a rejected GET is low-signal probing noise and\n * would amplify audit volume under a scan. Never throws.\n *\n * The permission gates here call it themselves. Export it for data-driven checks\n * a route makes inline (cross-org access, service-only endpoints), so those 403s\n * reach the same `authz.denied` trail. `required` names what was missing.\n */\nexport function recordAuthzDenial(req: Request, required: string): void {\n  const auditor = authzDenialAuditor;\n  if (!auditor) return;\n  const method = req.method.toUpperCase();\n  if (method === 'GET' || method === 'HEAD' || method === 'OPTIONS') return;\n  try {\n    auditor({\n      actorId: req.user?.sub,\n      actorEmail: req.user?.email,\n      orgId: req.user?.organizationId,\n      method,\n      // Strip the query string — a denied request may carry a token/secret as a\n      // query param, and this path is persisted verbatim into the audit log.\n      path: (req.originalUrl || req.url).split('?')[0],\n      required,\n    });\n  } catch {\n    // Best-effort — a broken auditor must never break the auth gate.\n  }\n}\n\n/** The shared gate preamble: answer 401 and return false when unauthenticated. */\nfunction requireUser(req: Request, res: Response): req is Request & { user: NonNullable<Request['user']> } {\n  if (req.user) return true;\n  sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n  return false;\n}\n\n/** Audit + answer a permission refusal (`missing` defaults to every required permission). */\nfunction denyPermission(req: Request, res: Response, permissions: Permission[], mode: 'or' | 'and', missing: Permission[] = permissions): void {\n  recordAuthzDenial(req, permissions.join(` ${mode} `));\n  sendError(\n    res, HttpStatus.FORBIDDEN,\n    `Missing required permission: ${missing.join(` ${mode} `)}`,\n    ErrorCode.INSUFFICIENT_PERMISSIONS,\n  );\n}\n\n/**\n * Requires that the user hold AT LEAST ONE of the given permissions (or be a\n * superadmin). Use after requireAuth. Mirrors `requireRole`'s any-of semantics;\n * pass a single permission for a specific action, or several when any one of\n * them should grant access.\n */\nexport function requirePermission(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!requireUser(req, res)) return;\n    // userHasPermission → hasPermission already grants superadmins every\n    // permission, so this single check covers both the superadmin bypass and\n    // the any-of membership test without re-inlining either.\n    if (permissions.some((p) => userHasPermission(req, p))) return next();\n    denyPermission(req, res, permissions, 'or');\n  }, { kind: 'permission', mode: 'any', permissions });\n}\n\n/**\n * Requires that the user hold EVERY one of the given permissions (or be a\n * superadmin) — the AND counterpart to `requirePermission`'s any-of. Use for a\n * sensitive action that legitimately demands two distinct capabilities at once\n * (e.g. a cross-surface operation), so the guarantee is explicit rather than\n * approximated by chaining two `requirePermission` gates. Superadmins bypass\n * (they implicitly hold every permission).\n */\nexport function requireAllPermissions(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!requireUser(req, res)) return;\n    const missing = permissions.filter((p) => !userHasPermission(req, p));\n    if (missing.length === 0) return next();\n    denyPermission(req, res, permissions, 'and', missing);\n  }, { kind: 'permission', mode: 'all', permissions });\n}\n\n/**\n * Like {@link requirePermission} (any-of) but ALSO admits an internal service\n * principal (`principalType: 'service'`). For READ endpoints that BOTH\n * interactive users — who must hold one of the `:read` capabilities — AND\n * service-to-service callers legitimately hit; service tokens carry no\n * permission claims (they're least-privilege `role:member`), so a plain\n * `requirePermission` would wrongly 403 them. Superadmins pass via\n * `userHasPermission`'s implicit-all. Use only where a service caller is a known,\n * intended consumer of the route (verify the callers); prefer plain\n * `requirePermission` for purely user-facing reads.\n */\nexport function requirePermissionOrService(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!requireUser(req, res)) return;\n    if (isServicePrincipal(req) || permissions.some((p) => userHasPermission(req, p))) return next();\n    denyPermission(req, res, permissions, 'or');\n  }, { kind: 'permission', mode: 'any', permissions, allowService: true });\n}\n\n/**\n * Gate an endpoint to internal service-to-service callers only (a\n * `principalType: 'service'` principal minted via {@link signServiceToken} / `getServiceAuthHeader`).\n * Rejects any user token. For NON-user-facing endpoints — entity-event ingest,\n * auto-subscribe, and similar peer-service hooks — that a browser must never\n * reach. Compose after `requireAuth` so `req.user` is populated.\n */\nexport function requireServicePrincipal(req: Request, res: Response, next: NextFunction): void {\n  if (!isServicePrincipal(req)) {\n    // 403 (not 400) — this is an authorization refusal; status must match the\n    // INSUFFICIENT_PERMISSIONS code and the sibling gates (requirePermission, etc.).\n    return sendError(res, HttpStatus.FORBIDDEN, 'Internal service calls only', ErrorCode.INSUFFICIENT_PERMISSIONS);\n  }\n  next();\n}\ntagRouteGate(requireServicePrincipal, { kind: 'servicePrincipal' });\n\n/**\n * THE gate for an INTERNAL route — the one every `/internal/*` path, the\n * quota usage counters, the entity-event ingest and the audit ingest go through.\n *\n * Two rules, both fail-closed:\n *\n *  1. **No user token, ever.** Not a member's, not a superadmin's, not a\n *     service-account key's. An internal route is a peer-service API surface, so\n *     \"a sufficiently privileged human\" is not an acceptable caller — that\n *     equivalence is exactly how a browser-reachable path becomes a tenant\n *     boundary bug. `requireServicePrincipal` already refused users; this also\n *     closes the `|| isSystemAdmin(req)` escape hatches that had grown around\n *     the individual internal routes.\n *  2. **Only the NAMED callers.** `callers` lists the services that legitimately\n *     call this route, and the name is cryptographically bound to the signing\n *     key (`services/service-keys.ts`), so this is an identity check rather than\n *     a claim check. It is the same allow-list the mesh policy names, at the\n *     layer that also holds in docker compose, where there is no mesh at all —\n *     the Istio `AuthorizationPolicy` is defence in depth on top, never the\n *     enforcement.\n *\n * Compose after `requireAuth` so `req.user` is populated. Refusals are counted\n * (`internal_route_refused_total`) and audited through the shared `authz.denied`\n * sink.\n */\nexport function requireInternalService(options: { callers: readonly string[] }) {\n  const allowed = new Set(options.callers);\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    const refuse = (reason: 'unauthenticated' | 'user_token' | 'wrong_caller'): void => {\n      emitCounter('internal_route_refused_total', {\n        service: serviceIdentity(),\n        route: req.route?.path ? `${req.method} ${req.baseUrl}${req.route.path}` : `${req.method} ${(req.originalUrl || req.url).split('?')[0]}`,\n        reason,\n        caller: serviceNameOf(req.user) ?? 'none',\n      });\n      recordAuthzDenial(req, `internal-service (${options.callers.join(', ')})`);\n      if (reason === 'unauthenticated') {\n        return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n      }\n      logger.warn('Refused an internal route', { reason, path: (req.originalUrl || req.url).split('?')[0], caller: serviceNameOf(req.user) });\n      return sendError(res, HttpStatus.FORBIDDEN, 'Internal service calls only', ErrorCode.INSUFFICIENT_PERMISSIONS);\n    };\n\n    if (!req.user) return refuse('unauthenticated');\n    if (!isServicePrincipal(req)) return refuse('user_token');\n    const caller = serviceNameOf(req.user);\n    if (!caller || !allowed.has(caller)) return refuse('wrong_caller');\n    next();\n  }, { kind: 'servicePrincipal' }, { kind: 'internalService', callers: [...options.callers] });\n}\n\n/**\n * Check if the request is from a system admin.\n *\n * Authority is granted solely by the user-level `isSuperAdmin` flag carried\n * in the JWT — never by membership in the well-known 'system' org, which would\n * conflate a Pipeline Builder operator with a customer tenant and let any\n * write that created a 'system'-named org quietly grant cross-org authority. The `system` org still exists as a *content holder* for shared\n * sample data; it confers no privilege.\n */\nexport function isSystemAdmin(req: Request): boolean {\n  return req.user?.isSuperAdmin === true;\n}\n\n/**\n * Whether the request's token carries a specific capability `scope` (e.g.\n * `'reporting:ingest'`). Used to gate endpoints that accept a narrow machine\n * identity — a normal interactive user token has no `scope` and returns false.\n */\nexport function hasScope(req: Request, scope: string): boolean {\n  return req.user?.scope === scope;\n}\n\n/** Requires a system admin — granted solely by the `isSuperAdmin` token claim.\n *  Use after requireAuth. */\nexport function requireSystemAdmin(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  if (!isSystemAdmin(req)) {\n    recordAuthzDenial(req, 'system-admin');\n    return sendError(\n      res, HttpStatus.FORBIDDEN,\n      'Access denied. Only system administrators can perform this action.',\n      ErrorCode.INSUFFICIENT_PERMISSIONS,\n    );\n  }\n  next();\n}\ntagRouteGate(requireSystemAdmin, { kind: 'systemAdmin' });\n\n/**\n * Require a specific feature flag. Use after requireAuth.\n * Checks the `features` array in the JWT payload (set at token issuance).\n * Sysadmins (isSuperAdmin) bypass — they always have every feature.\n */\nexport function requireFeature(feature: string) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!requireUser(req, res)) return;\n\n    // Sysadmins get all features; the `features` array on their token is\n    // populated with every flag at issuance time but the bypass here keeps\n    // the rule explicit and survives a token issued before a new feature\n    // flag was added.\n    if (req.user.isSuperAdmin === true) return next();\n\n    if (!req.user.features?.includes(feature)) {\n      // Route feature-gate denials through the same audit sink as\n      // requirePermission / requireSystemAdmin so a probe for an\n      // unentitled capability leaves a trail (state-changing methods only).\n      recordAuthzDenial(req, `feature:${feature}`);\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        `This feature requires a higher plan (${feature})`,\n        ErrorCode.INSUFFICIENT_PERMISSIONS,\n      );\n    }\n\n    next();\n  }, { kind: 'feature', feature });\n}\n\n"]}

package/lib/middleware/revocation.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Session invalidation: the token-version revocation store and the
+ * impersonation-session liveness check `requireAuth` consults after verifying a token.
+ */
+import { type JwtPayload } from '../types/common.js';
+/**
+ * A source of the CURRENT `tokenVersion` for a user, backed by a store the
+ * stateless services can read (in practice a Redis key the platform publishes
+ * to on every privilege change). Registered via {@link setTokenRevocationStore}.
+ *
+ * `getCurrentVersion` returns the user's current version, or `null` when the
+ * store has no entry — a miss is treated as "no known revocation" (fail-open):
+ * revocation entries are published with a TTL matching the access-token
+ * lifetime, so a missing entry means any token old enough to predate it has
+ * already expired on its own.
+ */
+export interface TokenRevocationStore {
+    getCurrentVersion(userId: string): Promise<number | null>;
+    /**
+     * Whether one IMPERSONATION session (by token `jti`) has been ended early.
+     *
+     * Optional so a store that predates it still links — but a store WITHOUT it
+     * cannot answer, and an impersonation token is then REJECTED. Unlike
+     * `getCurrentVersion`, this is deliberately not fail-open: the platform ends a
+     * session when someone withdraws consent, and a withdrawn consent that keeps
+     * working in every other service is not withdrawn.
+     */
+    getSessionRevocation?(jti: string): Promise<SessionRevocationState>;
+    /**
+     * Whether ONE credential the token rides on has been revoked — its session
+     * slot (`sid`) or the access key it was exchanged from / derived from (see
+     * {@link credentialRevocationRefs}). Fail-open like `getCurrentVersion`: a
+     * store that can't answer returns `false`.
+     */
+    isCredentialRevoked?(refs: CredentialRevocationRefs): Promise<boolean>;
+}
+/** The single-credential ids a token can be revoked by (`revoke:sid:` / `revoke:key:`). */
+export interface CredentialRevocationRefs {
+    /** The refresh-session slot the token was minted with. */
+    sid?: string;
+    /** Access-key ids: the exchanged key's own `jti`, and any `parentKeyId`. */
+    keyIds: string[];
+}
+/**
+ * The credential ids a verified token can be revoked by. An exchanged key token
+ * (`token_use: 'api_key'`) is named by its `jti`; a token derived from one
+ * carries `parentKeyId`; a session-minted token carries `sid`. Returns `null`
+ * when the token names none of them.
+ */
+export declare function credentialRevocationRefs(claims: Pick<JwtPayload, 'sid' | 'parentKeyId' | 'jti' | 'token_use'>): CredentialRevocationRefs | null;
+/**
+ * `revoked`     — the session was ended; reject.
+ * `live`        — no revocation recorded; allow.
+ * `unavailable` — the store couldn't be read or can't answer; REJECT. Distinct
+ *                 from `live` precisely so an outage can't read as "not revoked".
+ */
+export type SessionRevocationState = 'revoked' | 'live' | 'unavailable';
+/**
+ * Register (or clear, with `undefined`) the process-wide token-revocation store.
+ * When unset (the default), `requireAuth` performs NO revocation check (it relies
+ * on the short access-token TTL); services opt in at boot by wiring their Redis
+ * client. Platform keeps its own Mongo-backed check and need not register one.
+ */
+export declare function setTokenRevocationStore(store: TokenRevocationStore | undefined): void;
+/**
+ * Whether a request is a WRITE under a read-only impersonation token. Fail-closed
+ * on a missing method: only a request positively known to be a read passes.
+ */
+export declare function isImpersonationWriteBlocked(method: string | undefined, claims: Pick<JwtPayload, 'impersonationReadOnly'>): boolean;
+/**
+ * Public revocation check for routes that verify a platform JWT OUTSIDE
+ * `requireAuth` (e.g. the image-registry `/token` mint path, which resolves
+ * identity itself). Returns true when the token's `tokenVersion` is strictly
+ * behind the store's current version. Fail-open (never throws) — a store outage
+ * or a token/store without a usable version yields false (allow), matching
+ * `requireAuth`. Pass the verified JWT claims (`sub`, `tokenVersion`).
+ */
+export declare function isAccessTokenRevoked(claims: {
+    sub?: string;
+    tokenVersion?: number;
+    jti?: string;
+    impersonatorId?: string;
+    sid?: string;
+    parentKeyId?: string;
+    token_use?: JwtPayload['token_use'];
+}): Promise<boolean>;
+/** Whether `requireAuth` must consult the revocation stores for this token. */
+export declare function needsRevocationCheck(decoded: JwtPayload): boolean;
+/**
+ * The post-verification session-invalidation check. Returns the refusal
+ * message, or `null` when the session is live. An impersonation session is
+ * checked even when NO store is registered: there, no store ⇒ unavailable ⇒
+ * refused (see `TokenRevocationStore.getSessionRevocation`); the tokenVersion
+ * check is a no-op without a store and fails open on a store error. Never rejects.
+ */
+export declare function checkRevocation(decoded: JwtPayload): Promise<string | null>;

package/lib/middleware/revocation.js

@@ -0,0 +1,162 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Session invalidation: the token-version revocation store and the
+ * impersonation-session liveness check `requireAuth` consults after verifying a token.
+ */
+import {} from '../types/common.js';
+import { createLogger } from '../utils/logger.js';
+const logger = createLogger('auth-middleware');
+/**
+ * The credential ids a verified token can be revoked by. An exchanged key token
+ * (`token_use: 'api_key'`) is named by its `jti`; a token derived from one
+ * carries `parentKeyId`; a session-minted token carries `sid`. Returns `null`
+ * when the token names none of them.
+ */
+export function credentialRevocationRefs(claims) {
+    const keyIds = new Set();
+    if (claims.token_use === 'api_key' && typeof claims.jti === 'string' && claims.jti)
+        keyIds.add(claims.jti);
+    if (typeof claims.parentKeyId === 'string' && claims.parentKeyId)
+        keyIds.add(claims.parentKeyId);
+    const sid = typeof claims.sid === 'string' && claims.sid ? claims.sid : undefined;
+    if (!sid && keyIds.size === 0)
+        return null;
+    return { ...(sid ? { sid } : {}), keyIds: [...keyIds] };
+}
+let tokenRevocationStore;
+/**
+ * Register (or clear, with `undefined`) the process-wide token-revocation store.
+ * When unset (the default), `requireAuth` performs NO revocation check (it relies
+ * on the short access-token TTL); services opt in at boot by wiring their Redis
+ * client. Platform keeps its own Mongo-backed check and need not register one.
+ */
+export function setTokenRevocationStore(store) {
+    tokenRevocationStore = store;
+    if (store)
+        revocationStoreMissingWarned = false; // re-arm if a store is (re)registered
+}
+/** One-shot guard so the "revocation inactive" warning doesn't flood the logs. */
+let revocationStoreMissingWarned = false;
+/**
+ * Returns true when `decoded` has been revoked per the registered store: its
+ * embedded `tokenVersion` is strictly behind the store's current version.
+ * Fail-open — any store error, a missing entry, or a token/store without a
+ * usable version yields `false` (allow). Never throws.
+ */
+async function isTokenRevoked(decoded) {
+    const store = tokenRevocationStore;
+    if (!store) {
+        // Make the "revocation is OFF" state OBSERVABLE: a service that verifies user
+        // tokens but forgot `setTokenRevocationStore()` silently disables the session
+        // kill-switch. Warn ONCE (only for a revocable user token) so a misconfigured
+        // boot surfaces in the logs instead of failing open invisibly.
+        if (!revocationStoreMissingWarned && decoded.sub && typeof decoded.tokenVersion === 'number') {
+            revocationStoreMissingWarned = true;
+            logger.warn('Token revocation store NOT registered — revocation checks are INACTIVE (setTokenRevocationStore was never called); revoked/compromised sessions stay valid until natural TTL');
+        }
+        return false;
+    }
+    if (store.isCredentialRevoked) {
+        const refs = credentialRevocationRefs(decoded);
+        if (refs) {
+            try {
+                if (await store.isCredentialRevoked(refs))
+                    return true;
+            }
+            catch {
+                // Fail-open, as below.
+            }
+        }
+    }
+    if (!decoded.sub || typeof decoded.tokenVersion !== 'number')
+        return false;
+    try {
+        const current = await store.getCurrentVersion(decoded.sub);
+        return current !== null && decoded.tokenVersion < current;
+    }
+    catch {
+        // Fail-open: a revocation-store outage must not lock every user out.
+        return false;
+    }
+}
+/** Whether the registered store has anything to say about this token. */
+function hasRevocationCheck(decoded) {
+    const store = tokenRevocationStore;
+    if (!store)
+        return false;
+    if (decoded.sub && typeof decoded.tokenVersion === 'number')
+        return true;
+    return !!store.isCredentialRevoked && credentialRevocationRefs(decoded) !== null;
+}
+/** Methods a read-only impersonation token may use. */
+const IMPERSONATION_READ_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);
+/**
+ * Whether a request is a WRITE under a read-only impersonation token. Fail-closed
+ * on a missing method: only a request positively known to be a read passes.
+ */
+export function isImpersonationWriteBlocked(method, claims) {
+    return claims.impersonationReadOnly === true && !IMPERSONATION_READ_METHODS.has((method ?? '').toUpperCase());
+}
+/**
+ * Resolve an impersonation session's revocation state. Never throws: any failure
+ * — no store, a store that can't answer, a read error — is `unavailable`, which
+ * callers treat as revoked.
+ */
+async function sessionRevocationState(jti) {
+    const store = tokenRevocationStore;
+    if (!store?.getSessionRevocation)
+        return 'unavailable';
+    try {
+        return await store.getSessionRevocation(jti);
+    }
+    catch {
+        return 'unavailable';
+    }
+}
+/** An impersonation session token: it names the operator AND carries its own session id. */
+function isImpersonationSession(decoded) {
+    return typeof decoded.impersonatorId === 'string' && typeof decoded.jti === 'string' && decoded.jti.length > 0;
+}
+/**
+ * Public revocation check for routes that verify a platform JWT OUTSIDE
+ * `requireAuth` (e.g. the image-registry `/token` mint path, which resolves
+ * identity itself). Returns true when the token's `tokenVersion` is strictly
+ * behind the store's current version. Fail-open (never throws) — a store outage
+ * or a token/store without a usable version yields false (allow), matching
+ * `requireAuth`. Pass the verified JWT claims (`sub`, `tokenVersion`).
+ */
+export async function isAccessTokenRevoked(claims) {
+    // An impersonation session is revoked unless the store positively says live —
+    // including on this out-of-band path, or a revoked session could still mint
+    // registry tokens.
+    if (isImpersonationSession(claims) && await sessionRevocationState(claims.jti) !== 'live')
+        return true;
+    return isTokenRevoked(claims);
+}
+/** Whether `requireAuth` must consult the revocation stores for this token. */
+export function needsRevocationCheck(decoded) {
+    return isImpersonationSession(decoded) || hasRevocationCheck(decoded);
+}
+/**
+ * The post-verification session-invalidation check. Returns the refusal
+ * message, or `null` when the session is live. An impersonation session is
+ * checked even when NO store is registered: there, no store ⇒ unavailable ⇒
+ * refused (see `TokenRevocationStore.getSessionRevocation`); the tokenVersion
+ * check is a no-op without a store and fails open on a store error. Never rejects.
+ */
+export async function checkRevocation(decoded) {
+    if (isImpersonationSession(decoded)) {
+        const state = await sessionRevocationState(decoded.jti);
+        if (state !== 'live') {
+            return state === 'revoked'
+                ? 'This impersonation session has been ended'
+                : 'This impersonation session could not be verified';
+        }
+    }
+    if (hasRevocationCheck(decoded) && await isTokenRevoked(decoded)) {
+        return 'Session has been revoked; please sign in again';
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"revocation.js","sourceRoot":"","sources":["../../src/middleware/revocation.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Session invalidation: the token-version revocation store and the\n * impersonation-session liveness check `requireAuth` consults after verifying a token.\n */\n\nimport { type JwtPayload } from '../types/common.js';\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('auth-middleware');\n/**\n * A source of the CURRENT `tokenVersion` for a user, backed by a store the\n * stateless services can read (in practice a Redis key the platform publishes\n * to on every privilege change). Registered via {@link setTokenRevocationStore}.\n *\n * `getCurrentVersion` returns the user's current version, or `null` when the\n * store has no entry — a miss is treated as \"no known revocation\" (fail-open):\n * revocation entries are published with a TTL matching the access-token\n * lifetime, so a missing entry means any token old enough to predate it has\n * already expired on its own.\n */\nexport interface TokenRevocationStore {\n  getCurrentVersion(userId: string): Promise<number | null>;\n  /**\n   * Whether one IMPERSONATION session (by token `jti`) has been ended early.\n   *\n   * Optional so a store that predates it still links — but a store WITHOUT it\n   * cannot answer, and an impersonation token is then REJECTED. Unlike\n   * `getCurrentVersion`, this is deliberately not fail-open: the platform ends a\n   * session when someone withdraws consent, and a withdrawn consent that keeps\n   * working in every other service is not withdrawn.\n   */\n  getSessionRevocation?(jti: string): Promise<SessionRevocationState>;\n  /**\n   * Whether ONE credential the token rides on has been revoked — its session\n   * slot (`sid`) or the access key it was exchanged from / derived from (see\n   * {@link credentialRevocationRefs}). Fail-open like `getCurrentVersion`: a\n   * store that can't answer returns `false`.\n   */\n  isCredentialRevoked?(refs: CredentialRevocationRefs): Promise<boolean>;\n}\n\n/** The single-credential ids a token can be revoked by (`revoke:sid:` / `revoke:key:`). */\nexport interface CredentialRevocationRefs {\n  /** The refresh-session slot the token was minted with. */\n  sid?: string;\n  /** Access-key ids: the exchanged key's own `jti`, and any `parentKeyId`. */\n  keyIds: string[];\n}\n\n/**\n * The credential ids a verified token can be revoked by. An exchanged key token\n * (`token_use: 'api_key'`) is named by its `jti`; a token derived from one\n * carries `parentKeyId`; a session-minted token carries `sid`. Returns `null`\n * when the token names none of them.\n */\nexport function credentialRevocationRefs(\n  claims: Pick<JwtPayload, 'sid' | 'parentKeyId' | 'jti' | 'token_use'>,\n): CredentialRevocationRefs | null {\n  const keyIds = new Set<string>();\n  if (claims.token_use === 'api_key' && typeof claims.jti === 'string' && claims.jti) keyIds.add(claims.jti);\n  if (typeof claims.parentKeyId === 'string' && claims.parentKeyId) keyIds.add(claims.parentKeyId);\n  const sid = typeof claims.sid === 'string' && claims.sid ? claims.sid : undefined;\n  if (!sid && keyIds.size === 0) return null;\n  return { ...(sid ? { sid } : {}), keyIds: [...keyIds] };\n}\n\n/**\n * `revoked`     — the session was ended; reject.\n * `live`        — no revocation recorded; allow.\n * `unavailable` — the store couldn't be read or can't answer; REJECT. Distinct\n *                 from `live` precisely so an outage can't read as \"not revoked\".\n */\nexport type SessionRevocationState = 'revoked' | 'live' | 'unavailable';\n\nlet tokenRevocationStore: TokenRevocationStore | undefined;\n\n/**\n * Register (or clear, with `undefined`) the process-wide token-revocation store.\n * When unset (the default), `requireAuth` performs NO revocation check (it relies\n * on the short access-token TTL); services opt in at boot by wiring their Redis\n * client. Platform keeps its own Mongo-backed check and need not register one.\n */\nexport function setTokenRevocationStore(store: TokenRevocationStore | undefined): void {\n  tokenRevocationStore = store;\n  if (store) revocationStoreMissingWarned = false; // re-arm if a store is (re)registered\n}\n\n/** One-shot guard so the \"revocation inactive\" warning doesn't flood the logs. */\nlet revocationStoreMissingWarned = false;\n\n/**\n * Returns true when `decoded` has been revoked per the registered store: its\n * embedded `tokenVersion` is strictly behind the store's current version.\n * Fail-open — any store error, a missing entry, or a token/store without a\n * usable version yields `false` (allow). Never throws.\n */\nasync function isTokenRevoked(decoded: JwtPayload): Promise<boolean> {\n  const store = tokenRevocationStore;\n  if (!store) {\n    // Make the \"revocation is OFF\" state OBSERVABLE: a service that verifies user\n    // tokens but forgot `setTokenRevocationStore()` silently disables the session\n    // kill-switch. Warn ONCE (only for a revocable user token) so a misconfigured\n    // boot surfaces in the logs instead of failing open invisibly.\n    if (!revocationStoreMissingWarned && decoded.sub && typeof decoded.tokenVersion === 'number') {\n      revocationStoreMissingWarned = true;\n      logger.warn('Token revocation store NOT registered — revocation checks are INACTIVE (setTokenRevocationStore was never called); revoked/compromised sessions stay valid until natural TTL');\n    }\n    return false;\n  }\n  if (store.isCredentialRevoked) {\n    const refs = credentialRevocationRefs(decoded);\n    if (refs) {\n      try {\n        if (await store.isCredentialRevoked(refs)) return true;\n      } catch {\n        // Fail-open, as below.\n      }\n    }\n  }\n  if (!decoded.sub || typeof decoded.tokenVersion !== 'number') return false;\n  try {\n    const current = await store.getCurrentVersion(decoded.sub);\n    return current !== null && decoded.tokenVersion < current;\n  } catch {\n    // Fail-open: a revocation-store outage must not lock every user out.\n    return false;\n  }\n}\n\n/** Whether the registered store has anything to say about this token. */\nfunction hasRevocationCheck(decoded: JwtPayload): boolean {\n  const store = tokenRevocationStore;\n  if (!store) return false;\n  if (decoded.sub && typeof decoded.tokenVersion === 'number') return true;\n  return !!store.isCredentialRevoked && credentialRevocationRefs(decoded) !== null;\n}\n\n/** Methods a read-only impersonation token may use. */\nconst IMPERSONATION_READ_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);\n\n/**\n * Whether a request is a WRITE under a read-only impersonation token. Fail-closed\n * on a missing method: only a request positively known to be a read passes.\n */\nexport function isImpersonationWriteBlocked(\n  method: string | undefined,\n  claims: Pick<JwtPayload, 'impersonationReadOnly'>,\n): boolean {\n  return claims.impersonationReadOnly === true && !IMPERSONATION_READ_METHODS.has((method ?? '').toUpperCase());\n}\n\n/**\n * Resolve an impersonation session's revocation state. Never throws: any failure\n * — no store, a store that can't answer, a read error — is `unavailable`, which\n * callers treat as revoked.\n */\nasync function sessionRevocationState(jti: string): Promise<SessionRevocationState> {\n  const store = tokenRevocationStore;\n  if (!store?.getSessionRevocation) return 'unavailable';\n  try {\n    return await store.getSessionRevocation(jti);\n  } catch {\n    return 'unavailable';\n  }\n}\n\n/** An impersonation session token: it names the operator AND carries its own session id. */\nfunction isImpersonationSession(decoded: { impersonatorId?: unknown; jti?: unknown }): decoded is { impersonatorId: string; jti: string } {\n  return typeof decoded.impersonatorId === 'string' && typeof decoded.jti === 'string' && decoded.jti.length > 0;\n}\n\n/**\n * Public revocation check for routes that verify a platform JWT OUTSIDE\n * `requireAuth` (e.g. the image-registry `/token` mint path, which resolves\n * identity itself). Returns true when the token's `tokenVersion` is strictly\n * behind the store's current version. Fail-open (never throws) — a store outage\n * or a token/store without a usable version yields false (allow), matching\n * `requireAuth`. Pass the verified JWT claims (`sub`, `tokenVersion`).\n */\nexport async function isAccessTokenRevoked(\n  claims: {\n    sub?: string;\n    tokenVersion?: number;\n    jti?: string;\n    impersonatorId?: string;\n    sid?: string;\n    parentKeyId?: string;\n    token_use?: JwtPayload['token_use'];\n  },\n): Promise<boolean> {\n  // An impersonation session is revoked unless the store positively says live —\n  // including on this out-of-band path, or a revoked session could still mint\n  // registry tokens.\n  if (isImpersonationSession(claims) && await sessionRevocationState(claims.jti) !== 'live') return true;\n  return isTokenRevoked(claims as unknown as JwtPayload);\n}\n\n\n/** Whether `requireAuth` must consult the revocation stores for this token. */\nexport function needsRevocationCheck(decoded: JwtPayload): boolean {\n  return isImpersonationSession(decoded) || hasRevocationCheck(decoded);\n}\n\n/**\n * The post-verification session-invalidation check. Returns the refusal\n * message, or `null` when the session is live. An impersonation session is\n * checked even when NO store is registered: there, no store ⇒ unavailable ⇒\n * refused (see `TokenRevocationStore.getSessionRevocation`); the tokenVersion\n * check is a no-op without a store and fails open on a store error. Never rejects.\n */\nexport async function checkRevocation(decoded: JwtPayload): Promise<string | null> {\n  if (isImpersonationSession(decoded)) {\n    const state = await sessionRevocationState(decoded.jti);\n    if (state !== 'live') {\n      return state === 'revoked'\n        ? 'This impersonation session has been ended'\n        : 'This impersonation session could not be verified';\n    }\n  }\n  if (hasRevocationCheck(decoded) && await isTokenRevoked(decoded)) {\n    return 'Session has been revoked; please sign in again';\n  }\n  return null;\n}\n"]}

package/lib/middleware/route-table.d.ts

@@ -46,6 +46,11 @@ export type RouteGate = {
  | {
     kind: 'orgAdminAssurance';
     machines: OrgAdminAssuranceMachines;
+}
+/** The caller's ACTIVE org must be the system org (`requireSystemOrg`) — the
+ *  plugin-ecosystem governance boundary (docs/runbooks/ecosystem-moderation.md). */
+ | {
+    kind: 'systemOrg';
 } | {
     kind: 'feature';
     feature: string;
@@ -118,6 +123,12 @@ export interface RouteTableEntry {
     orgAdminAssurance?: {
         machines: OrgAdminAssuranceMachines;
     };
+    /**
+     * Present (always `true`) when the chain runs `requireSystemOrg`: only a
+     * caller whose active org is the system org gets through. Absent otherwise,
+     * so the table of a service with no ecosystem-governance route is unchanged.
+     */
+    systemOrg?: true;
     features: string[];
     scopes: string[];
     audit: string[];