@pipeline-builder/api-core 3.4.87 → 3.4.89

package/lib/middleware/auth.d.ts

@@ -15,6 +15,28 @@ export interface RequireAuthOptions {
 /** JWT auth middleware. Use directly or call with options. */
 export declare function requireAuth(req: Request, res: Response, next: NextFunction): void;
 export declare function requireAuth(options?: RequireAuthOptions): (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * 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>;
+}
+/**
+ * Register (or clear, with `undefined`) the process-wide token-revocation store.
+ * When unset (the default), `requireAuth` performs NO revocation check and
+ * behaves exactly as before — so this is fully backward compatible and 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;
 /**
  * Requires admin role. Use after requireAuth.
  * Permits users whose per-org role is 'admin' or 'owner'.
@@ -26,6 +48,28 @@ export declare function requireAdmin(req: Request, res: Response, next: NextFunc
  * or re-derived per request by the platform).
  */
 export declare function userHasPermission(req: Request, permission: Permission): boolean;
+/**
+ * Context passed to a registered authorization-denial auditor when a
+ * state-changing request is rejected by `requirePermission` /
+ * `requireSystemAdmin`.
+ */
+export interface AuthzDenialInfo {
+    /** The denied user's id (`sub`), if authenticated. */
+    actorId?: string;
+    actorEmail?: string;
+    /** The user's active org at denial time. */
+    orgId?: string;
+    /** HTTP method + path of the rejected request. */
+    method: string;
+    path: string;
+    /** What was required: the missing permission(s), or 'system-admin'. */
+    required: string;
+}
+/**
+ * Register (or clear, with `undefined`) the process-wide authorization-denial
+ * auditor. Idempotent; the last registration wins.
+ */
+export declare function setAuthzDenialAuditor(fn: ((info: AuthzDenialInfo) => void) | undefined): void;
 /**
  * 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;
@@ -33,6 +77,15 @@ export declare function userHasPermission(req: Request, permission: Permission):
  * them should grant access.
  */
 export declare function requirePermission(...permissions: Permission[]): (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * 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 declare function requireAllPermissions(...permissions: Permission[]): (req: Request, res: Response, next: NextFunction) => void;
 /**
  * The system tenant's canonical org **id** — a fixed, well-known ObjectId (NOT
  * the string 'system'). This is the single knob every service resolves the

package/lib/middleware/auth.js

@@ -1,5 +1,6 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+import { randomUUID } from 'crypto';
 import jwt from 'jsonwebtoken';
 import { HttpStatus } from '../constants/http-status.js';
 import { ErrorCode } from '../types/error-codes.js';
@@ -94,6 +95,36 @@ export function requireAuth(reqOrOptions, res, next) {
         _requireAuth(options, req, resInner, nextInner);
     };
 }
+let tokenRevocationStore;
+/**
+ * Register (or clear, with `undefined`) the process-wide token-revocation store.
+ * When unset (the default), `requireAuth` performs NO revocation check and
+ * behaves exactly as before — so this is fully backward compatible and 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;
+}
+/**
+ * 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 || !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;
+    }
+}
 function _requireAuth(options, req, res, next) {
     const authHeader = req.headers.authorization;
     if (!authHeader) {
@@ -141,6 +172,27 @@ function _requireAuth(options, req, res, next) {
             if (headerOrgName)
                 req.user.organizationName = headerOrgName;
         }
+        // Session-invalidation check for the stateless services: reject a token
+        // whose `tokenVersion` is behind the revocation store's current value (a
+        // privilege change the platform published). No store registered ⇒ this is a
+        // no-op and control passes straight through. Fail-open on any store error.
+        if (tokenRevocationStore && decoded.sub && typeof decoded.tokenVersion === 'number') {
+            // `.catch(next)` forwards a DOWNSTREAM synchronous throw from `next()` to
+            // Express's error middleware — without it, that throw would surface as an
+            // unhandled rejection (this `next()` runs in a microtask, outside the
+            // surrounding try/catch and Express's per-layer dispatch). `isTokenRevoked`
+            // itself never rejects (it fail-opens internally), so the catch only ever
+            // sees a genuine downstream error.
+            isTokenRevoked(decoded)
+                .then((revoked) => {
+                if (revoked) {
+                    return sendError(res, HttpStatus.UNAUTHORIZED, 'Session has been revoked; please sign in again', ErrorCode.TOKEN_REVOKED);
+                }
+                next();
+            })
+                .catch(next);
+            return;
+        }
         next();
     }
     catch (error) {
@@ -174,6 +226,48 @@ export function requireAdmin(req, res, next) {
 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.
+ */
+function auditAuthzDenial(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,
+            path: req.originalUrl || req.url,
+            required,
+        });
+    }
+    catch {
+        // Best-effort — a broken auditor must never break the auth gate.
+    }
+}
 /**
  * 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;
@@ -190,9 +284,30 @@ export function requirePermission(...permissions) {
         // the any-of membership test without re-inlining either.
         if (permissions.some((p) => userHasPermission(req, p)))
             return next();
+        auditAuthzDenial(req, permissions.join(' or '));
         return sendError(res, HttpStatus.FORBIDDEN, `Missing required permission: ${permissions.join(' or ')}`, ErrorCode.INSUFFICIENT_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 (req, res, next) => {
+        if (!req.user) {
+            return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);
+        }
+        const missing = permissions.filter((p) => !userHasPermission(req, p));
+        if (missing.length === 0)
+            return next();
+        auditAuthzDenial(req, permissions.join(' and '));
+        return sendError(res, HttpStatus.FORBIDDEN, `Missing required permission: ${missing.join(' and ')}`, ErrorCode.INSUFFICIENT_PERMISSIONS);
+    };
+}
 /**
  * The system tenant's canonical org **id** — a fixed, well-known ObjectId (NOT
  * the string 'system'). This is the single knob every service resolves the
@@ -237,6 +352,7 @@ export function hasScope(req, scope) {
 /** Requires system admin (admin role + system organization). */
 export function requireSystemAdmin(req, res, next) {
     if (!isSystemAdmin(req)) {
+        auditAuthzDenial(req, 'system-admin');
         return sendError(res, HttpStatus.FORBIDDEN, 'Access denied. Only system administrators can perform this action.', ErrorCode.INSUFFICIENT_PERMISSIONS);
     }
     next();
@@ -315,6 +431,13 @@ export function signServiceToken(opts) {
         // Sign with the same configured alg requireAuth pins on verify, so service
         // tokens stay valid under a non-default JWT_ALGORITHM.
         algorithm: (process.env.JWT_ALGORITHM || 'HS256'),
+        // Unique token id on every mint. Combined with the short (300s default) TTL
+        // this gives each service token a distinct identity — the building block for
+        // replay detection (a verifier can track seen jtis) and the correlation
+        // handle for tracing which mint performed a cross-service action. It does
+        // NOT by itself prevent replay within the TTL window; true replay defence
+        // needs the asymmetric-key work tracked separately.
+        jwtid: randomUUID(),
     };
     if (process.env.JWT_ISSUER)
         signOptions.issuer = process.env.JWT_ISSUER;
@@ -356,4 +479,4 @@ export function verifyServicePrincipal(req) {
         return false;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/middleware/auth.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAGtC,OAAO,GAAG,MAAM,cAAc,CAAC;AAC/B,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAEzD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAmB,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,MAAM,MAAM,GAAG,YAAY,CAAC,iBAAiB,CAAC,CAAC;AAE/C,4DAA4D;AAC5D,IAAI,UAA8B,CAAC;AACnC,IAAI,qBAAqB,GAAG,CAAC,CAAC;AAC9B,8EAA8E;AAC9E,IAAI,kBAAsC,CAAC;AAC3C,IAAI,6BAA6B,GAAG,CAAC,CAAC;AACtC,MAAM,8BAA8B,GAAG,OAAO,CAAC,CAAC,YAAY;AAE5D,SAAS,YAAY;IACnB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACvB,IAAI,CAAC,UAAU,IAAI,GAAG,GAAG,qBAAqB,GAAG,8BAA8B,EAAE,CAAC;QAChF,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC;QACtC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,CAAC,KAAK,CAAC,4CAA4C,CAAC,CAAC;YAC3D,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;QACjE,CAAC;QACD,IAAI,UAAU,IAAI,UAAU,KAAK,MAAM,EAAE,CAAC;YACxC,MAAM,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;QACpC,CAAC;QACD,UAAU,GAAG,MAAM,CAAC;QACpB,qBAAqB,GAAG,GAAG,CAAC;IAC9B,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,oBAAoB;IAC3B,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACvB,IAAI,GAAG,GAAG,6BAA6B,GAAG,8BAA8B,EAAE,CAAC;QACzE,kBAAkB,GAAG,OAAO,CAAC,GAAG,CAAC,mBAAmB,IAAI,SAAS,CAAC;QAClE,6BAA6B,GAAG,GAAG,CAAC;IACtC,CAAC;IACD,OAAO,kBAAkB,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,SAAS,qBAAqB,CAAC,KAAa,EAAE,aAAgC;IAC5E,IAAI,CAAC;QACH,OAAO,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,YAAY,EAAE,EAAE,aAAa,CAAe,CAAC;IACxE,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,QAAQ,GAAG,oBAAoB,EAAE,CAAC;QACxC,6EAA6E;QAC7E,8EAA8E;QAC9E,qEAAqE;QACrE,IACE,QAAQ;eACL,GAAG,YAAY,GAAG,CAAC,iBAAiB;eACpC,CAAC,CAAC,GAAG,YAAY,GAAG,CAAC,iBAAiB,CAAC;eACvC,CAAC,CAAC,GAAG,YAAY,GAAG,CAAC,cAAc,CAAC,EACvC,CAAC;YACD,wEAAwE;YACxE,0EAA0E;YAC1E,wDAAwD;YACxD,OAAO,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,aAAa,CAAe,CAAC;QAClE,CAAC;QACD,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC;AAwBD,MAAM,UAAU,WAAW,CACzB,YAA2C,EAC3C,GAAc,EACd,IAAmB;IAEnB,IAAI,YAAY,IAAI,GAAG,IAAI,IAAI,IAAI,SAAS,IAAI,YAAY,EAAE,CAAC;QAC7D,OAAO,YAAY,CAAC,EAAE,EAAE,YAAuB,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;IAC9D,CAAC;IAED,MAAM,OAAO,GAAI,YAAmC,IAAI,EAAE,CAAC;IAC3D,OAAO,CAAC,GAAY,EAAE,QAAkB,EAAE,SAAuB,EAAE,EAAE;QACnE,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;IAClD,CAAC,CAAC;AACJ,CAAC;AAED,SAAS,YAAY,CACnB,OAA2B,EAC3B,GAAY,EACZ,GAAa,EACb,IAAkB;IAElB,MAAM,UAAU,GAAG,GAAG,CAAC,OAAO,CAAC,aAAa,CAAC;IAE7C,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,+BAA+B,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC;IAC3G,CAAC;IAED,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACpC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ,EAAE,CAAC;QAChD,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,mDAAmD,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC;IAC/H,CAAC;IAED,IAAI,CAAC;QACH,0EAA0E;QAC1E,sEAAsE;QACtE,yEAAyE;QACzE,oDAAoD;QACpD,yEAAyE;QACzE,wEAAwE;QACxE,sEAAsE;QACtE,sEAAsE;QACtE,wEAAwE;QACxE,MAAM,aAAa,GAAsB,EAAE,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,OAAO,CAAkB,CAAC,EAAE,CAAC;QACnH,MAAM,cAAc,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC;QAC9C,MAAM,gBAAgB,GAAG,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC;QAClD,IAAI,cAAc;YAAE,aAAa,CAAC,MAAM,GAAG,cAAc,CAAC;QAC1D,IAAI,gBAAgB;YAAE,aAAa,CAAC,QAAQ,GAAG,gBAAgB,CAAC;QAChE,MAAM,OAAO,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC;QAE/D,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC9B,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,iDAAiD,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC;QAC7H,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;YAClC,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,+BAA+B,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC;QAC3G,CAAC;QAED,GAAG,CAAC,IAAI,GAAG,EAAE,GAAG,OAAO,EAAE,CAAC;QAE1B,wEAAwE;QACxE,8EAA8E;QAC9E,8EAA8E;QAC9E,8EAA8E;QAC9E,4EAA4E;QAC5E,IAAI,OAAO,CAAC,sBAAsB,IAAI,OAAO,CAAC,YAAY,KAAK,IAAI,EAAE,CAAC;YACpE,MAAM,WAAW,GAAG,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;YAC7D,MAAM,aAAa,GAAG,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC;YACjE,IAAI,WAAW;gBAAE,GAAG,CAAC,IAAI,CAAC,cAAc,GAAG,WAAW,CAAC;YACvD,IAAI,aAAa;gBAAE,GAAG,CAAC,IAAI,CAAC,gBAAgB,GAAG,aAAa,CAAC;QAC/D,CAAC;QAED,IAAI,EAAE,CAAC;IACT,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,GAAG,CAAC,iBAAiB,EAAE,CAAC;YAC3C,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,mBAAmB,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC;QAC/F,CAAC;QAED,IAAI,KAAK,YAAY,GAAG,CAAC,iBAAiB,EAAE,CAAC;YAC3C,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,eAAe,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC;QAC3F,CAAC;QAED,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,uBAAuB,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;IAClG,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAC1B,GAAY,EACZ,GAAa,EACb,IAAkB;IAElB,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;QACd,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,yBAAyB,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;IACpG,CAAC;IAED,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,KAAK,OAAO,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QAC3D,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,SAAS,EAAE,uBAAuB,EAAE,SAAS,CAAC,wBAAwB,CAAC,CAAC;IAC3G,CAAC;IAED,IAAI,EAAE,CAAC;AACT,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAY,EAAE,UAAsB;IACpE,OAAO,aAAa,CAAC,GAAG,CAAC,IAAI,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;AAClF,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAG,WAAyB;IAC5D,OAAO,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB,EAAQ,EAAE;QAC/D,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;YACd,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,yBAAyB,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;QACpG,CAAC;QACD,qEAAqE;QACrE,yEAAyE;QACzE,yDAAyD;QACzD,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;YAAE,OAAO,IAAI,EAAE,CAAC;QACtE,OAAO,SAAS,CACd,GAAG,EAAE,UAAU,CAAC,SAAS,EACzB,gCAAgC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,EAC1D,SAAS,CAAC,wBAAwB,CACnC,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,0BAA0B,CAAC,CAAC,WAAW,EAAE,CAAC;AAErG,wGAAwG;AACxG,MAAM,CAAC,MAAM,eAAe,GAAG,QAAQ,CAAC;AAExC;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,KAAc,EAAE,OAAgB;IAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,KAAK,aAAa,IAAI,OAAO,EAAE,WAAW,EAAE,KAAK,eAAe,CAAC;AAC9F,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,aAAa,CAAC,GAAY;IACxC,OAAO,GAAG,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;AACzC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CAAC,GAAY,EAAE,KAAa;IAClD,OAAO,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,KAAK,CAAC;AACnC,CAAC;AAED,gEAAgE;AAChE,MAAM,UAAU,kBAAkB,CAChC,GAAY,EACZ,GAAa,EACb,IAAkB;IAElB,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC;QACxB,OAAO,SAAS,CACd,GAAG,EAAE,UAAU,CAAC,SAAS,EACzB,oEAAoE,EACpE,SAAS,CAAC,wBAAwB,CACnC,CAAC;IACJ,CAAC;IACD,IAAI,EAAE,CAAC;AACT,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,OAAe;IAC5C,OAAO,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB,EAAQ,EAAE;QAC/D,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;YACd,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,yBAAyB,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;QACpG,CAAC;QAED,qEAAqE;QACrE,uEAAuE;QACvE,qEAAqE;QACrE,kBAAkB;QAClB,IAAI,GAAG,CAAC,IAAI,CAAC,YAAY,KAAK,IAAI;YAAE,OAAO,IAAI,EAAE,CAAC;QAElD,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC1C,OAAO,SAAS,CACd,GAAG,EAAE,UAAU,CAAC,SAAS,EACzB,wCAAwC,OAAO,GAAG,EAClD,SAAS,CAAC,wBAAwB,CACnC,CAAC;QACJ,CAAC;QAED,IAAI,EAAE,CAAC;IACT,CAAC,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,GAAY,EAAE,SAA6B;IAC/E,IAAI,SAAS,KAAK,QAAQ,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,IAAI,GAAG,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,EAAE,CAAC;QACzF,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,8EAA8E;AAC9E,4BAA4B;AAC5B,EAAE;AACF,4EAA4E;AAC5E,sEAAsE;AACtE,oEAAoE;AACpE,2EAA2E;AAC3E,6EAA6E;AAC7E,oEAAoE;AACpE,6DAA6D;AAC7D,EAAE;AACF,yEAAyE;AACzE,iDAAiD;AACjD,8EAA8E;AAE9E,MAAM,iCAAiC,GAAG,GAAG,CAAC;AAoB9C;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAyB;IACxD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;IACvB,MAAM,OAAO,GAAe;QAC1B,GAAG,EAAE,WAAW,IAAI,CAAC,WAAW,EAAE;QAClC,QAAQ,EAAE,GAAG,IAAI,CAAC,WAAW,UAAU;QACvC,KAAK,EAAE,GAAG,IAAI,CAAC,WAAW,WAAW;QACrC,IAAI;QACJ,OAAO,EAAE,IAAI,KAAK,OAAO,IAAI,IAAI,KAAK,OAAO;QAC7C,IAAI,EAAE,QAAQ;QACd,cAAc,EAAE,IAAI,CAAC,KAAK;QAC1B,gBAAgB,EAAE,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,KAAK;KAC7C,CAAC;IACF,qEAAqE;IACrE,oEAAoE;IACpE,oEAAoE;IACpE,MAAM,WAAW,GAAoB;QACnC,SAAS,EAAE,IAAI,CAAC,UAAU,IAAI,iCAAiC;QAC/D,2EAA2E;QAC3E,uDAAuD;QACvD,SAAS,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,OAAO,CAAkB;KACnE,CAAC;IACF,IAAI,OAAO,CAAC,GAAG,CAAC,UAAU;QAAE,WAAW,CAAC,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC;IACxE,IAAI,OAAO,CAAC,GAAG,CAAC,YAAY;QAAE,WAAW,CAAC,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC;IAC9E,OAAO,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,WAAW,CAAC,CAAC;AACxD,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,oBAAoB,CAAC,IAAyB;IAC5D,OAAO,UAAU,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;AAC5C,CAAC;AAED,+FAA+F;AAC/F,MAAM,UAAU,kBAAkB,CAAC,GAAY;IAC7C,OAAO,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,UAAU,CAAC,UAAU,CAAC,IAAI,KAAK,CAAC;AACxD,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,sBAAsB,CAAC,GAAY;IACjD,MAAM,KAAK,GAAG,GAAG,CAAC,OAAO,CAAC,aAAa,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACpD,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IACxE,IAAI,CAAC;QACH,MAAM,aAAa,GAAsB,EAAE,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,OAAO,CAAkB,CAAC,EAAE,CAAC;QACnH,IAAI,OAAO,CAAC,GAAG,CAAC,UAAU;YAAE,aAAa,CAAC,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC;QAC1E,IAAI,OAAO,CAAC,GAAG,CAAC,YAAY;YAAE,aAAa,CAAC,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC;QAChF,MAAM,OAAO,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC;QAC/D,OAAO,OAAO,CAAC,IAAI,KAAK,QAAQ,IAAI,OAAO,OAAO,CAAC,GAAG,KAAK,QAAQ,IAAI,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;IAC5G,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Request, Response, NextFunction } from 'express';\nimport jwt from 'jsonwebtoken';\nimport { HttpStatus } from '../constants/http-status.js';\nimport type { JwtPayload } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { type Permission, hasPermission } from '../types/permissions.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { createLogger } from '../utils/logger.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('auth-middleware');\n\n/** Cached JWT secret with periodic refresh from env var. */\nlet _jwtSecret: string | undefined;\nlet _jwtSecretRefreshedAt = 0;\n/** Cached PREVIOUS JWT secret (optional) — enables zero-downtime rotation. */\nlet _jwtSecretPrevious: string | undefined;\nlet _jwtSecretPreviousRefreshedAt = 0;\nconst JWT_SECRET_REFRESH_INTERVAL_MS = 300_000; // 5 minutes\n\nfunction getJwtSecret(): string {\n  const now = Date.now();\n  if (!_jwtSecret || now - _jwtSecretRefreshedAt > JWT_SECRET_REFRESH_INTERVAL_MS) {\n    const secret = process.env.JWT_SECRET;\n    if (!secret) {\n      logger.error('JWT_SECRET environment variable is not set');\n      throw new Error('JWT_SECRET environment variable is required');\n    }\n    if (_jwtSecret && _jwtSecret !== secret) {\n      logger.info('JWT secret rotated');\n    }\n    _jwtSecret = secret;\n    _jwtSecretRefreshedAt = now;\n  }\n  return _jwtSecret;\n}\n\n/**\n * The optional PREVIOUS JWT secret (`JWT_SECRET_PREVIOUS`), cached with the same\n * TTL as the primary. Returns `undefined` when unset. During a `JWT_SECRET`\n * rotation, operators set `JWT_SECRET_PREVIOUS` to the old value so tokens signed\n * with EITHER secret keep verifying — closing the auth-outage window where\n * still-valid old-signed (or freshly new-signed) tokens would otherwise be\n * rejected. `undefined` is a valid cached value, so this refreshes purely on the\n * time interval (not on emptiness).\n */\nfunction getJwtSecretPrevious(): string | undefined {\n  const now = Date.now();\n  if (now - _jwtSecretPreviousRefreshedAt > JWT_SECRET_REFRESH_INTERVAL_MS) {\n    _jwtSecretPrevious = process.env.JWT_SECRET_PREVIOUS || undefined;\n    _jwtSecretPreviousRefreshedAt = now;\n  }\n  return _jwtSecretPrevious;\n}\n\n/**\n * Verify a JWT against the primary secret, falling back to the previous secret\n * (when `JWT_SECRET_PREVIOUS` is configured) ONLY on a signature/verification\n * failure. This makes token verification survive a secret rotation with zero\n * downtime: a token valid under EITHER secret passes.\n *\n * jsonwebtoken's `verify` takes a single secret, so this is try-primary-then-\n * previous — NOT a secret array. No existing check is weakened:\n *   - `verifyOptions` (algorithm pinning + optional issuer/audience) is applied\n *     identically on BOTH attempts, so alg-confusion / `alg:none` stay blocked.\n *   - Expiry / not-before from the PRIMARY attempt are authoritative and are\n *     re-thrown without a previous-secret retry, so a `TokenExpiredError` is\n *     never masked into an \"invalid signature\".\n *   - When no previous secret is set, behaviour is byte-for-byte the original:\n *     the primary error propagates unchanged.\n */\nfunction verifyJwtWithRotation(token: string, verifyOptions: jwt.VerifyOptions): JwtPayload {\n  try {\n    return jwt.verify(token, getJwtSecret(), verifyOptions) as JwtPayload;\n  } catch (err) {\n    const previous = getJwtSecretPrevious();\n    // Fall back to the previous secret only for a signature/verification failure\n    // (a plain JsonWebTokenError). Expiry / not-before are enforced regardless of\n    // which secret signed the token, so those errors must surface as-is.\n    if (\n      previous\n      && err instanceof jwt.JsonWebTokenError\n      && !(err instanceof jwt.TokenExpiredError)\n      && !(err instanceof jwt.NotBeforeError)\n    ) {\n      // A token signed by the previous secret verifies here; if it is instead\n      // expired/invalid under the previous secret, that error propagates and is\n      // handled by the caller exactly like a primary failure.\n      return jwt.verify(token, previous, verifyOptions) as JwtPayload;\n    }\n    throw err;\n  }\n}\n\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\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  return (req: Request, resInner: Response, nextInner: NextFunction) => {\n    _requireAuth(options, req, resInner, nextInner);\n  };\n}\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  try {\n    // Pass through optional issuer/audience verification when env-configured.\n    // Without these, a JWT signed by any system that happens to share the\n    // same JWT_SECRET would be accepted — defence-in-depth for shared-secret\n    // misconfigurations across services / environments.\n    // Pin the accepted algorithm to the configured HMAC alg (default HS256).\n    // Without an allow-list, `jwt.verify` accepts any algorithm the key can\n    // verify — the classic alg-confusion vector (and a hard guard against\n    // `alg:none`). Env-driven so it stays in lockstep with how tokens are\n    // signed (see signServiceToken + platform's config.auth.jwt.algorithm).\n    const verifyOptions: jwt.VerifyOptions = { algorithms: [(process.env.JWT_ALGORITHM || 'HS256') as jwt.Algorithm] };\n    const expectedIssuer = process.env.JWT_ISSUER;\n    const expectedAudience = process.env.JWT_AUDIENCE;\n    if (expectedIssuer) verifyOptions.issuer = expectedIssuer;\n    if (expectedAudience) verifyOptions.audience = expectedAudience;\n    const decoded = verifyJwtWithRotation(parts[1], verifyOptions);\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) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token missing required fields', ErrorCode.TOKEN_INVALID);\n    }\n\n    req.user = { ...decoded };\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    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    if (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/**\n * Requires admin role. Use after requireAuth.\n * Permits users whose per-org role is 'admin' or 'owner'.\n */\nexport function requireAdmin(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  if (!req.user) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n  }\n\n  if (req.user.role !== 'admin' && req.user.role !== 'owner') {\n    return sendError(res, HttpStatus.FORBIDDEN, 'Admin access required', ErrorCode.INSUFFICIENT_PERMISSIONS);\n  }\n\n  next();\n}\n\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 * 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 (req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\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    return sendError(\n      res, HttpStatus.FORBIDDEN,\n      `Missing required permission: ${permissions.join(' or ')}`,\n      ErrorCode.INSUFFICIENT_PERMISSIONS,\n    );\n  };\n}\n\n/**\n * The system tenant's canonical org **id** — a fixed, well-known ObjectId (NOT\n * the string 'system'). This is the single knob every service resolves the\n * system tenant through; override via the `SYSTEM_ORG_ID` env for alternate\n * installs. The system org's human identifier stays the slug/name 'system'\n * (see {@link SYSTEM_ORG_SLUG}); only its `_id` is this ObjectId.\n */\nexport const SYSTEM_ORG_ID = (process.env.SYSTEM_ORG_ID || '000000000000000000000001').toLowerCase();\n\n/** The system org's well-known slug/name (the human identifier; its `_id` is {@link SYSTEM_ORG_ID}). */\nexport const SYSTEM_ORG_SLUG = 'system';\n\n/**\n * Check if an orgId or orgName/slug matches the system org. Use this instead of\n * comparing directly: the id is now an ObjectId ({@link SYSTEM_ORG_ID}) while the\n * name/slug is 'system' ({@link SYSTEM_ORG_SLUG}), so the two are compared against\n * their respective canonical values.\n */\nexport function isSystemOrgId(orgId?: string, orgName?: string): boolean {\n  return orgId?.toLowerCase() === SYSTEM_ORG_ID || orgName?.toLowerCase() === SYSTEM_ORG_SLUG;\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. The \"membership in the well-known 'system' org with role\n * admin/owner\" path was removed — it conflated a Pipeline Builder operator\n * with a real customer tenant in the data model, and meant any unintended\n * write that created a 'system'-named org could quietly grant cross-org\n * authority. The `system` org still exists as a *content holder* for shared\n * sample data; it just no longer confers 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 system admin (admin role + system organization). */\nexport function requireSystemAdmin(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  if (!isSystemAdmin(req)) {\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}\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 (req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\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      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        `This feature requires a higher plan (${feature})`,\n        ErrorCode.INSUFFICIENT_PERMISSIONS,\n      );\n    }\n\n    next();\n  };\n}\n\n/**\n * Resolve the effective access modifier for an entity being created/updated.\n * 'public' is permitted for any admin or owner role (system admins create\n * catalog-wide public entities; org admins create org-wide public entities).\n * Everyone else (member role, no role) gets 'private'.\n */\nexport function resolveAccessModifier(req: Request, requested: string | undefined): 'public' | 'private' {\n  if (requested === 'public' && (req.user?.role === 'admin' || req.user?.role === 'owner')) {\n    return 'public';\n  }\n  return 'private';\n}\n\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 JWT signed with the shared\n// JWT_SECRET, identifying the calling service via `sub: 'service:<name>'`.\n// `requireAuth` accepts these tokens transparently — they pass `decoded.sub`\n// and `decoded.role` checks, and downstream `requireOrganization` /\n// `requireAdmin` 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\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 'system' for system-wide ops. */\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\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 */\nexport function signServiceToken(opts: ServiceTokenOptions): string {\n  const role = opts.role;\n  const payload: JwtPayload = {\n    sub: `service:${opts.serviceName}`,\n    username: `${opts.serviceName}-service`,\n    email: `${opts.serviceName}@internal`,\n    role,\n    isAdmin: role === 'owner' || role === 'admin',\n    type: 'access',\n    organizationId: opts.orgId,\n    organizationName: opts.orgName ?? opts.orgId,\n  };\n  // Match the optional issuer/audience that requireAuth verifies, when\n  // configured. Without these, a service token signed here would fail\n  // requireAuth in a deployment that has set JWT_ISSUER/JWT_AUDIENCE.\n  const signOptions: jwt.SignOptions = {\n    expiresIn: opts.ttlSeconds ?? DEFAULT_SERVICE_TOKEN_TTL_SECONDS,\n    // Sign with the same configured alg requireAuth pins on verify, so service\n    // tokens stay valid under a non-default JWT_ALGORITHM.\n    algorithm: (process.env.JWT_ALGORITHM || 'HS256') as jwt.Algorithm,\n  };\n  if (process.env.JWT_ISSUER) signOptions.issuer = process.env.JWT_ISSUER;\n  if (process.env.JWT_AUDIENCE) signOptions.audience = process.env.JWT_AUDIENCE;\n  return jwt.sign(payload, getJwtSecret(), signOptions);\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.sub` was issued by `signServiceToken` (i.e. starts with `service:`). */\nexport function isServicePrincipal(req: Request): boolean {\n  return req.user?.sub?.startsWith('service:') ?? false;\n}\n\n/**\n * PRE-auth check: cryptographically verify the request carries a valid, signed\n * SERVICE token (`sub` starts with `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 verification (algorithm pinning + optional\n * issuer/audience) and returns `false` on any missing/invalid/non-service token.\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 verifyOptions: jwt.VerifyOptions = { algorithms: [(process.env.JWT_ALGORITHM || 'HS256') as jwt.Algorithm] };\n    if (process.env.JWT_ISSUER) verifyOptions.issuer = process.env.JWT_ISSUER;\n    if (process.env.JWT_AUDIENCE) verifyOptions.audience = process.env.JWT_AUDIENCE;\n    const decoded = verifyJwtWithRotation(parts[1], verifyOptions);\n    return decoded.type === 'access' && typeof decoded.sub === 'string' && decoded.sub.startsWith('service:');\n  } catch {\n    return false;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","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\nimport { randomUUID } from 'crypto';\nimport type { Request, Response, NextFunction } from 'express';\nimport jwt from 'jsonwebtoken';\nimport { HttpStatus } from '../constants/http-status.js';\nimport type { JwtPayload } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { type Permission, hasPermission } from '../types/permissions.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { createLogger } from '../utils/logger.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('auth-middleware');\n\n/** Cached JWT secret with periodic refresh from env var. */\nlet _jwtSecret: string | undefined;\nlet _jwtSecretRefreshedAt = 0;\n/** Cached PREVIOUS JWT secret (optional) — enables zero-downtime rotation. */\nlet _jwtSecretPrevious: string | undefined;\nlet _jwtSecretPreviousRefreshedAt = 0;\nconst JWT_SECRET_REFRESH_INTERVAL_MS = 300_000; // 5 minutes\n\nfunction getJwtSecret(): string {\n  const now = Date.now();\n  if (!_jwtSecret || now - _jwtSecretRefreshedAt > JWT_SECRET_REFRESH_INTERVAL_MS) {\n    const secret = process.env.JWT_SECRET;\n    if (!secret) {\n      logger.error('JWT_SECRET environment variable is not set');\n      throw new Error('JWT_SECRET environment variable is required');\n    }\n    if (_jwtSecret && _jwtSecret !== secret) {\n      logger.info('JWT secret rotated');\n    }\n    _jwtSecret = secret;\n    _jwtSecretRefreshedAt = now;\n  }\n  return _jwtSecret;\n}\n\n/**\n * The optional PREVIOUS JWT secret (`JWT_SECRET_PREVIOUS`), cached with the same\n * TTL as the primary. Returns `undefined` when unset. During a `JWT_SECRET`\n * rotation, operators set `JWT_SECRET_PREVIOUS` to the old value so tokens signed\n * with EITHER secret keep verifying — closing the auth-outage window where\n * still-valid old-signed (or freshly new-signed) tokens would otherwise be\n * rejected. `undefined` is a valid cached value, so this refreshes purely on the\n * time interval (not on emptiness).\n */\nfunction getJwtSecretPrevious(): string | undefined {\n  const now = Date.now();\n  if (now - _jwtSecretPreviousRefreshedAt > JWT_SECRET_REFRESH_INTERVAL_MS) {\n    _jwtSecretPrevious = process.env.JWT_SECRET_PREVIOUS || undefined;\n    _jwtSecretPreviousRefreshedAt = now;\n  }\n  return _jwtSecretPrevious;\n}\n\n/**\n * Verify a JWT against the primary secret, falling back to the previous secret\n * (when `JWT_SECRET_PREVIOUS` is configured) ONLY on a signature/verification\n * failure. This makes token verification survive a secret rotation with zero\n * downtime: a token valid under EITHER secret passes.\n *\n * jsonwebtoken's `verify` takes a single secret, so this is try-primary-then-\n * previous — NOT a secret array. No existing check is weakened:\n *   - `verifyOptions` (algorithm pinning + optional issuer/audience) is applied\n *     identically on BOTH attempts, so alg-confusion / `alg:none` stay blocked.\n *   - Expiry / not-before from the PRIMARY attempt are authoritative and are\n *     re-thrown without a previous-secret retry, so a `TokenExpiredError` is\n *     never masked into an \"invalid signature\".\n *   - When no previous secret is set, behaviour is byte-for-byte the original:\n *     the primary error propagates unchanged.\n */\nfunction verifyJwtWithRotation(token: string, verifyOptions: jwt.VerifyOptions): JwtPayload {\n  try {\n    return jwt.verify(token, getJwtSecret(), verifyOptions) as JwtPayload;\n  } catch (err) {\n    const previous = getJwtSecretPrevious();\n    // Fall back to the previous secret only for a signature/verification failure\n    // (a plain JsonWebTokenError). Expiry / not-before are enforced regardless of\n    // which secret signed the token, so those errors must surface as-is.\n    if (\n      previous\n      && err instanceof jwt.JsonWebTokenError\n      && !(err instanceof jwt.TokenExpiredError)\n      && !(err instanceof jwt.NotBeforeError)\n    ) {\n      // A token signed by the previous secret verifies here; if it is instead\n      // expired/invalid under the previous secret, that error propagates and is\n      // handled by the caller exactly like a primary failure.\n      return jwt.verify(token, previous, verifyOptions) as JwtPayload;\n    }\n    throw err;\n  }\n}\n\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\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  return (req: Request, resInner: Response, nextInner: NextFunction) => {\n    _requireAuth(options, req, resInner, nextInner);\n  };\n}\n\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\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 and\n * behaves exactly as before — so this is fully backward compatible and services\n * opt in at boot by wiring their Redis client. Platform keeps its own Mongo-\n * backed check and need not register one.\n */\nexport function setTokenRevocationStore(store: TokenRevocationStore | undefined): void {\n  tokenRevocationStore = store;\n}\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 || !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\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  try {\n    // Pass through optional issuer/audience verification when env-configured.\n    // Without these, a JWT signed by any system that happens to share the\n    // same JWT_SECRET would be accepted — defence-in-depth for shared-secret\n    // misconfigurations across services / environments.\n    // Pin the accepted algorithm to the configured HMAC alg (default HS256).\n    // Without an allow-list, `jwt.verify` accepts any algorithm the key can\n    // verify — the classic alg-confusion vector (and a hard guard against\n    // `alg:none`). Env-driven so it stays in lockstep with how tokens are\n    // signed (see signServiceToken + platform's config.auth.jwt.algorithm).\n    const verifyOptions: jwt.VerifyOptions = { algorithms: [(process.env.JWT_ALGORITHM || 'HS256') as jwt.Algorithm] };\n    const expectedIssuer = process.env.JWT_ISSUER;\n    const expectedAudience = process.env.JWT_AUDIENCE;\n    if (expectedIssuer) verifyOptions.issuer = expectedIssuer;\n    if (expectedAudience) verifyOptions.audience = expectedAudience;\n    const decoded = verifyJwtWithRotation(parts[1], verifyOptions);\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) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token missing required fields', ErrorCode.TOKEN_INVALID);\n    }\n\n    req.user = { ...decoded };\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    // Session-invalidation check for the stateless services: reject a token\n    // whose `tokenVersion` is behind the revocation store's current value (a\n    // privilege change the platform published). No store registered ⇒ this is a\n    // no-op and control passes straight through. Fail-open on any store error.\n    if (tokenRevocationStore && decoded.sub && typeof decoded.tokenVersion === 'number') {\n      // `.catch(next)` forwards a DOWNSTREAM synchronous throw from `next()` to\n      // Express's error middleware — without it, that throw would surface as an\n      // unhandled rejection (this `next()` runs in a microtask, outside the\n      // surrounding try/catch and Express's per-layer dispatch). `isTokenRevoked`\n      // itself never rejects (it fail-opens internally), so the catch only ever\n      // sees a genuine downstream error.\n      isTokenRevoked(decoded)\n        .then((revoked) => {\n          if (revoked) {\n            return sendError(res, HttpStatus.UNAUTHORIZED, 'Session has been revoked; please sign in again', ErrorCode.TOKEN_REVOKED);\n          }\n          next();\n        })\n        .catch(next);\n      return;\n    }\n\n    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    if (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/**\n * Requires admin role. Use after requireAuth.\n * Permits users whose per-org role is 'admin' or 'owner'.\n */\nexport function requireAdmin(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  if (!req.user) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n  }\n\n  if (req.user.role !== 'admin' && req.user.role !== 'owner') {\n    return sendError(res, HttpStatus.FORBIDDEN, 'Admin access required', ErrorCode.INSUFFICIENT_PERMISSIONS);\n  }\n\n  next();\n}\n\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 */\nfunction auditAuthzDenial(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      path: req.originalUrl || req.url,\n      required,\n    });\n  } catch {\n    // Best-effort — a broken auditor must never break the auth gate.\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 (req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\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    auditAuthzDenial(req, permissions.join(' or '));\n    return sendError(\n      res, HttpStatus.FORBIDDEN,\n      `Missing required permission: ${permissions.join(' or ')}`,\n      ErrorCode.INSUFFICIENT_PERMISSIONS,\n    );\n  };\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 (req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\n    const missing = permissions.filter((p) => !userHasPermission(req, p));\n    if (missing.length === 0) return next();\n    auditAuthzDenial(req, permissions.join(' and '));\n    return sendError(\n      res, HttpStatus.FORBIDDEN,\n      `Missing required permission: ${missing.join(' and ')}`,\n      ErrorCode.INSUFFICIENT_PERMISSIONS,\n    );\n  };\n}\n\n/**\n * The system tenant's canonical org **id** — a fixed, well-known ObjectId (NOT\n * the string 'system'). This is the single knob every service resolves the\n * system tenant through; override via the `SYSTEM_ORG_ID` env for alternate\n * installs. The system org's human identifier stays the slug/name 'system'\n * (see {@link SYSTEM_ORG_SLUG}); only its `_id` is this ObjectId.\n */\nexport const SYSTEM_ORG_ID = (process.env.SYSTEM_ORG_ID || '000000000000000000000001').toLowerCase();\n\n/** The system org's well-known slug/name (the human identifier; its `_id` is {@link SYSTEM_ORG_ID}). */\nexport const SYSTEM_ORG_SLUG = 'system';\n\n/**\n * Check if an orgId or orgName/slug matches the system org. Use this instead of\n * comparing directly: the id is now an ObjectId ({@link SYSTEM_ORG_ID}) while the\n * name/slug is 'system' ({@link SYSTEM_ORG_SLUG}), so the two are compared against\n * their respective canonical values.\n */\nexport function isSystemOrgId(orgId?: string, orgName?: string): boolean {\n  return orgId?.toLowerCase() === SYSTEM_ORG_ID || orgName?.toLowerCase() === SYSTEM_ORG_SLUG;\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. The \"membership in the well-known 'system' org with role\n * admin/owner\" path was removed — it conflated a Pipeline Builder operator\n * with a real customer tenant in the data model, and meant any unintended\n * write that created a 'system'-named org could quietly grant cross-org\n * authority. The `system` org still exists as a *content holder* for shared\n * sample data; it just no longer confers 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 system admin (admin role + system organization). */\nexport function requireSystemAdmin(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  if (!isSystemAdmin(req)) {\n    auditAuthzDenial(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}\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 (req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\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      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        `This feature requires a higher plan (${feature})`,\n        ErrorCode.INSUFFICIENT_PERMISSIONS,\n      );\n    }\n\n    next();\n  };\n}\n\n/**\n * Resolve the effective access modifier for an entity being created/updated.\n * 'public' is permitted for any admin or owner role (system admins create\n * catalog-wide public entities; org admins create org-wide public entities).\n * Everyone else (member role, no role) gets 'private'.\n */\nexport function resolveAccessModifier(req: Request, requested: string | undefined): 'public' | 'private' {\n  if (requested === 'public' && (req.user?.role === 'admin' || req.user?.role === 'owner')) {\n    return 'public';\n  }\n  return 'private';\n}\n\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 JWT signed with the shared\n// JWT_SECRET, identifying the calling service via `sub: 'service:<name>'`.\n// `requireAuth` accepts these tokens transparently — they pass `decoded.sub`\n// and `decoded.role` checks, and downstream `requireOrganization` /\n// `requireAdmin` 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\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 'system' for system-wide ops. */\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\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 */\nexport function signServiceToken(opts: ServiceTokenOptions): string {\n  const role = opts.role;\n  const payload: JwtPayload = {\n    sub: `service:${opts.serviceName}`,\n    username: `${opts.serviceName}-service`,\n    email: `${opts.serviceName}@internal`,\n    role,\n    isAdmin: role === 'owner' || role === 'admin',\n    type: 'access',\n    organizationId: opts.orgId,\n    organizationName: opts.orgName ?? opts.orgId,\n  };\n  // Match the optional issuer/audience that requireAuth verifies, when\n  // configured. Without these, a service token signed here would fail\n  // requireAuth in a deployment that has set JWT_ISSUER/JWT_AUDIENCE.\n  const signOptions: jwt.SignOptions = {\n    expiresIn: opts.ttlSeconds ?? DEFAULT_SERVICE_TOKEN_TTL_SECONDS,\n    // Sign with the same configured alg requireAuth pins on verify, so service\n    // tokens stay valid under a non-default JWT_ALGORITHM.\n    algorithm: (process.env.JWT_ALGORITHM || 'HS256') as jwt.Algorithm,\n    // Unique token id on every mint. Combined with the short (300s default) TTL\n    // this gives each service token a distinct identity — the building block for\n    // replay detection (a verifier can track seen jtis) and the correlation\n    // handle for tracing which mint performed a cross-service action. It does\n    // NOT by itself prevent replay within the TTL window; true replay defence\n    // needs the asymmetric-key work tracked separately.\n    jwtid: randomUUID(),\n  };\n  if (process.env.JWT_ISSUER) signOptions.issuer = process.env.JWT_ISSUER;\n  if (process.env.JWT_AUDIENCE) signOptions.audience = process.env.JWT_AUDIENCE;\n  return jwt.sign(payload, getJwtSecret(), signOptions);\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.sub` was issued by `signServiceToken` (i.e. starts with `service:`). */\nexport function isServicePrincipal(req: Request): boolean {\n  return req.user?.sub?.startsWith('service:') ?? false;\n}\n\n/**\n * PRE-auth check: cryptographically verify the request carries a valid, signed\n * SERVICE token (`sub` starts with `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 verification (algorithm pinning + optional\n * issuer/audience) and returns `false` on any missing/invalid/non-service token.\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 verifyOptions: jwt.VerifyOptions = { algorithms: [(process.env.JWT_ALGORITHM || 'HS256') as jwt.Algorithm] };\n    if (process.env.JWT_ISSUER) verifyOptions.issuer = process.env.JWT_ISSUER;\n    if (process.env.JWT_AUDIENCE) verifyOptions.audience = process.env.JWT_AUDIENCE;\n    const decoded = verifyJwtWithRotation(parts[1], verifyOptions);\n    return decoded.type === 'access' && typeof decoded.sub === 'string' && decoded.sub.startsWith('service:');\n  } catch {\n    return false;\n  }\n}\n"]}

package/lib/services/index.d.ts

@@ -9,4 +9,5 @@ export { DEFAULT_MAX_RETRIES, DEFAULT_RETRY_DELAY_MS, DEFAULT_MAX_RATE_LIMIT_RET
 export type { RetryConfig, RetryDecision } from './retry-strategy.js';
 export * from './quota.js';
 export * from './remote-audit-client.js';
+export * from './token-revocation.js';
 export { enqueueComplianceEvent, registerComplianceQueueBackend, type ComplianceEvent } from './compliance-queue.js';

package/lib/services/index.js

@@ -10,5 +10,6 @@ export * from './http-client.js';
 export { DEFAULT_MAX_RETRIES, DEFAULT_RETRY_DELAY_MS, DEFAULT_MAX_RATE_LIMIT_RETRIES, calculateBackoff, isTransientStatusCode, isRateLimited, getRetryDecision, getErrorRetryDecision, } from './retry-strategy.js';
 export * from './quota.js';
 export * from './remote-audit-client.js';
+export * from './token-revocation.js';
 export { enqueueComplianceEvent, registerComplianceQueueBackend } from './compliance-queue.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUV0QyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLE9BQU8sRUFDTCxtQkFBbUIsRUFDbkIsc0JBQXNCLEVBQ3RCLDhCQUE4QixFQUM5QixnQkFBZ0IsRUFDaEIscUJBQXFCLEVBQ3JCLGFBQWEsRUFDYixnQkFBZ0IsRUFDaEIscUJBQXFCLEdBQ3RCLE1BQU0scUJBQXFCLENBQUM7QUFFN0IsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsOEJBQThCLEVBQXdCLE1BQU0sdUJBQXVCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuZXhwb3J0ICogZnJvbSAnLi9jYWNoZS1zZXJ2aWNlLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vbGVhZGVyLWxvY2suanMnO1xuZXhwb3J0ICogZnJvbSAnLi9zY2hlZHVsZXIuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9jb21wbGlhbmNlLWNsaWVudC5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBsaWFuY2UtZXZlbnQtc3Vic2NyaWJlci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2VudGl0eS1ldmVudHMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9odHRwLWNsaWVudC5qcyc7XG5leHBvcnQge1xuICBERUZBVUxUX01BWF9SRVRSSUVTLFxuICBERUZBVUxUX1JFVFJZX0RFTEFZX01TLFxuICBERUZBVUxUX01BWF9SQVRFX0xJTUlUX1JFVFJJRVMsXG4gIGNhbGN1bGF0ZUJhY2tvZmYsXG4gIGlzVHJhbnNpZW50U3RhdHVzQ29kZSxcbiAgaXNSYXRlTGltaXRlZCxcbiAgZ2V0UmV0cnlEZWNpc2lvbixcbiAgZ2V0RXJyb3JSZXRyeURlY2lzaW9uLFxufSBmcm9tICcuL3JldHJ5LXN0cmF0ZWd5LmpzJztcbmV4cG9ydCB0eXBlIHsgUmV0cnlDb25maWcsIFJldHJ5RGVjaXNpb24gfSBmcm9tICcuL3JldHJ5LXN0cmF0ZWd5LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vcXVvdGEuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9yZW1vdGUtYXVkaXQtY2xpZW50LmpzJztcbmV4cG9ydCB7IGVucXVldWVDb21wbGlhbmNlRXZlbnQsIHJlZ2lzdGVyQ29tcGxpYW5jZVF1ZXVlQmFja2VuZCwgdHlwZSBDb21wbGlhbmNlRXZlbnQgfSBmcm9tICcuL2NvbXBsaWFuY2UtcXVldWUuanMnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUV0QyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLE9BQU8sRUFDTCxtQkFBbUIsRUFDbkIsc0JBQXNCLEVBQ3RCLDhCQUE4QixFQUM5QixnQkFBZ0IsRUFDaEIscUJBQXFCLEVBQ3JCLGFBQWEsRUFDYixnQkFBZ0IsRUFDaEIscUJBQXFCLEdBQ3RCLE1BQU0scUJBQXFCLENBQUM7QUFFN0IsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSw4QkFBOEIsRUFBd0IsTUFBTSx1QkFBdUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG5leHBvcnQgKiBmcm9tICcuL2NhY2hlLXNlcnZpY2UuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9sZWFkZXItbG9jay5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3NjaGVkdWxlci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBsaWFuY2UtY2xpZW50LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vY29tcGxpYW5jZS1ldmVudC1zdWJzY3JpYmVyLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vZW50aXR5LWV2ZW50cy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2h0dHAtY2xpZW50LmpzJztcbmV4cG9ydCB7XG4gIERFRkFVTFRfTUFYX1JFVFJJRVMsXG4gIERFRkFVTFRfUkVUUllfREVMQVlfTVMsXG4gIERFRkFVTFRfTUFYX1JBVEVfTElNSVRfUkVUUklFUyxcbiAgY2FsY3VsYXRlQmFja29mZixcbiAgaXNUcmFuc2llbnRTdGF0dXNDb2RlLFxuICBpc1JhdGVMaW1pdGVkLFxuICBnZXRSZXRyeURlY2lzaW9uLFxuICBnZXRFcnJvclJldHJ5RGVjaXNpb24sXG59IGZyb20gJy4vcmV0cnktc3RyYXRlZ3kuanMnO1xuZXhwb3J0IHR5cGUgeyBSZXRyeUNvbmZpZywgUmV0cnlEZWNpc2lvbiB9IGZyb20gJy4vcmV0cnktc3RyYXRlZ3kuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9xdW90YS5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3JlbW90ZS1hdWRpdC1jbGllbnQuanMnO1xuZXhwb3J0ICogZnJvbSAnLi90b2tlbi1yZXZvY2F0aW9uLmpzJztcbmV4cG9ydCB7IGVucXVldWVDb21wbGlhbmNlRXZlbnQsIHJlZ2lzdGVyQ29tcGxpYW5jZVF1ZXVlQmFja2VuZCwgdHlwZSBDb21wbGlhbmNlRXZlbnQgfSBmcm9tICcuL2NvbXBsaWFuY2UtcXVldWUuanMnO1xuIl19

package/lib/services/remote-audit-client.d.ts

@@ -4,7 +4,7 @@
  * actions are rejected by the platform ingest endpoint (400) so a drift is
  * visible in logs rather than silently dropped.
  */
-export type RemoteAuditAction = 'plugin.build.completed' | 'plugin.build.failed' | 'plugin.build.timeout';
+export type RemoteAuditAction = 'plugin.build.completed' | 'plugin.build.failed' | 'plugin.build.timeout' | 'plugin.delete' | 'plugin.upload' | 'plugin.deploy' | 'pipeline.create' | 'pipeline.update' | 'pipeline.delete' | 'pipeline.execution.start' | 'pipeline.execution.cancel' | 'quota.reset' | 'quota.limit.update' | 'compliance.exemption.approve' | 'compliance.rule.toggle' | 'compliance.scan.cancel' | 'registry.gc' | 'registry.image.delete' | 'authz.denied';
 export interface RemoteAuditEvent {
     action: RemoteAuditAction;
     actorId: string;
@@ -13,6 +13,12 @@ export interface RemoteAuditEvent {
     affectedOrgId?: string;
     targetType?: string;
     targetId?: string;
+    /**
+     * Did the audited action succeed or fail? Defaults to 'success' when omitted
+     * (the platform ingest applies the same default). Denied-authz events set
+     * 'failure' so a reviewer can filter attempts from completed actions.
+     */
+    outcome?: 'success' | 'failure';
     details?: Record<string, unknown>;
 }
 /**

package/lib/services/remote-audit-client.js

@@ -1,13 +1,22 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+import { randomUUID } from 'crypto';
 import { createSafeClient } from './http-client.js';
 import { getServiceAuthHeader } from '../middleware/auth.js';
 import { createLogger } from '../utils/logger.js';
 const logger = createLogger('remote-audit');
-/** Tight retries  audit ingest is best-effort, never block the caller. */
+/**
+ * Audit ingest is best-effort and MUST NOT block the caller, but a transient
+ * failure (429 / 5xx / connection reset / timeout) should not silently drop the
+ * row on the first attempt. Each emission carries a stable per-event
+ * `Idempotency-Key` (see `record`), so the http-client treats the POST as
+ * retry-safe and the platform can dedup a retried delivery instead of writing a
+ * duplicate row. Budget is kept small so a hard-down platform can't back the
+ * worker up for long: base delay ×(2 retries) + a couple of 429 backoffs.
+ */
 const AUDIT_REQUEST_OPTIONS = {
-    maxRateLimitRetries: 0,
-    maxRetries: 1,
+    maxRateLimitRetries: 2,
+    maxRetries: 2,
 };
 /**
  * Construct a remote-audit client targeted at the platform service.
@@ -39,14 +48,26 @@ export function createRemoteAuditClient(config = {}) {
     return {
         record(event, serviceName) {
             const authHeader = getServiceAuthHeader({ serviceName, orgId: event.orgId, role: 'member' });
-            // Strip the `Bearer ` prefix for InternalHttpClient  it sets the
-            // Authorization header itself; the value here is raw.
-            const headers = { Authorization: authHeader };
+            // getServiceAuthHeader returns a full `Bearer <token>` value; the
+            // http-client forwards request headers as-is (it does NOT inject its own
+            // Authorization), so pass it straight through as the Authorization header.
+            // A stable per-emission Idempotency-Key makes this non-idempotent POST
+            // retry-safe in the http-client (so transient 5xx/timeout/429 are retried
+            // rather than dropped) and lets the platform ingest dedup a re-delivered
+            // event instead of writing a duplicate audit row. Generated once here so
+            // every retry of THIS emission reuses the same key.
+            const headers = {
+                'Authorization': authHeader,
+                'Idempotency-Key': randomUUID(),
+            };
             // Path is /audit/events  the platform mounts the audit router under
             // /audit, and the internal ingest endpoint lives at /events under that.
             client.post('/audit/events', event, { headers, ...AUDIT_REQUEST_OPTIONS })
                 .then((response) => {
-                if (!response || response.statusCode !== 200) {
+                // Any 2xx is an accept (the ingest returns 200 today, but 201/202/204
+                // are equally "stored"); only a non-2xx / missing response warns.
+                const ok = response && response.statusCode >= 200 && response.statusCode < 300;
+                if (!ok) {
                     logger.warn('Remote audit ingest non-ok', {
                         action: event.action, statusCode: response?.statusCode,
                     });
@@ -61,4 +82,4 @@ export function createRemoteAuditClient(config = {}) {
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remote-audit-client.js","sourceRoot":"","sources":["../../src/services/remote-audit-client.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,gBAAgB,EAAuB,MAAM,kBAAkB,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAE7D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,MAAM,GAAG,YAAY,CAAC,cAAc,CAAC,CAAC;AAE5C,0EAA0E;AAC1E,MAAM,qBAAqB,GAA+D;IACxF,mBAAmB,EAAE,CAAC;IACtB,UAAU,EAAE,CAAC;CACd,CAAC;AAmDF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,uBAAuB,CAAC,SAAkC,EAAE;IAC1E,MAAM,aAAa,GAAkB;QACnC,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,qBAAqB,IAAI,UAAU;QACpE,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,qBAAqB,IAAI,MAAM,EAAE,EAAE,CAAC;QAC9E,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,IAAI;KAChC,CAAC;IACF,MAAM,MAAM,GAAG,gBAAgB,CAAC,aAAa,CAAC,CAAC;IAE/C,OAAO;QACL,MAAM,CAAC,KAAK,EAAE,WAAW;YACvB,MAAM,UAAU,GAAG,oBAAoB,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;YAC7F,iEAAiE;YACjE,sDAAsD;YACtD,MAAM,OAAO,GAA2B,EAAE,aAAa,EAAE,UAAU,EAAE,CAAC;YACtE,oEAAoE;YACpE,wEAAwE;YACxE,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,GAAG,qBAAqB,EAAE,CAAC;iBACvE,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE;gBACjB,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,UAAU,KAAK,GAAG,EAAE,CAAC;oBAC7C,MAAM,CAAC,IAAI,CAAC,4BAA4B,EAAE;wBACxC,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU;qBACvD,CAAC,CAAC;gBACL,CAAC;YACH,CAAC,CAAC;iBACD,KAAK,CAAC,CAAC,GAAY,EAAE,EAAE;gBACtB,MAAM,CAAC,IAAI,CAAC,2BAA2B,EAAE;oBACvC,MAAM,EAAE,KAAK,CAAC,MAAM;oBACpB,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAA,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;iBACvD,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACP,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createSafeClient, type RequestOptions } from './http-client.js';\nimport { getServiceAuthHeader } from '../middleware/auth.js';\nimport type { ServiceConfig } from '../types/common.js';\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('remote-audit');\n\n/** Tight retries  audit ingest is best-effort, never block the caller. */\nconst AUDIT_REQUEST_OPTIONS: Pick<RequestOptions, 'maxRateLimitRetries' | 'maxRetries'> = {\n  maxRateLimitRetries: 0,\n  maxRetries: 1,\n};\n\n/**\n * Subset of platform's AuditAction enum that non-platform services emit.\n * Kept in sync manually with platform/src/models/audit-event.ts; mismatched\n * actions are rejected by the platform ingest endpoint (400) so a drift is\n * visible in logs rather than silently dropped.\n */\nexport type RemoteAuditAction =\n  | 'plugin.build.completed'\n  | 'plugin.build.failed'\n  | 'plugin.build.timeout';\n\nexport interface RemoteAuditEvent {\n  action: RemoteAuditAction;\n  actorId: string;\n  actorEmail?: string;\n  orgId?: string;\n  affectedOrgId?: string;\n  targetType?: string;\n  targetId?: string;\n  details?: Record<string, unknown>;\n}\n\n/**\n * Client for POSTing audit events to the platform's `/audit-events` ingest\n * endpoint. Mints a fresh service token per call (5 min TTL)  there's no\n * meaningful caching benefit when emissions are sparse.\n */\nexport interface RemoteAuditClient {\n  /**\n   * Fire-and-forget audit emission. Failures are logged at warn level but\n   * never thrown  the originating action (e.g. a plugin build) has its\n   * own success/failure path that shouldn't get polluted by a flaky audit\n   * downstream.\n   */\n  record(event: RemoteAuditEvent, serviceName: string): void;\n}\n\n/**\n * Configuration for the remote audit client.\n */\nexport interface RemoteAuditClientConfig {\n  /** Platform service host (default: env PLATFORM_SERVICE_HOST or 'platform') */\n  host?: string;\n  /** Platform service port (default: env PLATFORM_SERVICE_PORT or 3000) */\n  port?: number;\n  /** Request timeout ms (default 3000  audit shouldn't block the worker). */\n  timeout?: number;\n}\n\n/**\n * Construct a remote-audit client targeted at the platform service.\n *\n * Used by api/plugin's build worker to push `plugin.build.*` events into\n * the platform's MongoDB `audit_events` collection. Other services\n * with worker-style emitters can use the same client.\n *\n * @example\n * ```typescript\n * const auditClient = createRemoteAuditClient();\n * auditClient.record({\n * action: 'plugin.build.completed',\n * actorId: 'user-123',\n * orgId: 'org-acme',\n * targetType: 'plugin',\n * targetId: 'plugin-abc',\n * details: { name: 'my-plugin', version: '1.0.0' },\n * }, 'plugin');\n * ```\n */\nexport function createRemoteAuditClient(config: RemoteAuditClientConfig = {}): RemoteAuditClient {\n  const serviceConfig: ServiceConfig = {\n    host: config.host ?? process.env.PLATFORM_SERVICE_HOST ?? 'platform',\n    port: config.port ?? parseInt(process.env.PLATFORM_SERVICE_PORT ?? '3000', 10),\n    timeout: config.timeout ?? 3000,\n  };\n  const client = createSafeClient(serviceConfig);\n\n  return {\n    record(event, serviceName) {\n      const authHeader = getServiceAuthHeader({ serviceName, orgId: event.orgId, role: 'member' });\n      // Strip the `Bearer ` prefix for InternalHttpClient  it sets the\n      // Authorization header itself; the value here is raw.\n      const headers: Record<string, string> = { Authorization: authHeader };\n      // Path is /audit/events  the platform mounts the audit router under\n      // /audit, and the internal ingest endpoint lives at /events under that.\n      client.post('/audit/events', event, { headers, ...AUDIT_REQUEST_OPTIONS })\n        .then((response) => {\n          if (!response || response.statusCode !== 200) {\n            logger.warn('Remote audit ingest non-ok', {\n              action: event.action, statusCode: response?.statusCode,\n            });\n          }\n        })\n        .catch((err: unknown) => {\n          logger.warn('Remote audit ingest threw', {\n            action: event.action,\n            error: err instanceof Error ? err.message: String(err),\n          });\n        });\n    },\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remote-audit-client.js","sourceRoot":"","sources":["../../src/services/remote-audit-client.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,gBAAgB,EAAuB,MAAM,kBAAkB,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAE7D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,MAAM,GAAG,YAAY,CAAC,cAAc,CAAC,CAAC;AAE5C;;;;;;;;GAQG;AACH,MAAM,qBAAqB,GAA+D;IACxF,mBAAmB,EAAE,CAAC;IACtB,UAAU,EAAE,CAAC;CACd,CAAC;AA4FF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,uBAAuB,CAAC,SAAkC,EAAE;IAC1E,MAAM,aAAa,GAAkB;QACnC,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,qBAAqB,IAAI,UAAU;QACpE,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,qBAAqB,IAAI,MAAM,EAAE,EAAE,CAAC;QAC9E,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,IAAI;KAChC,CAAC;IACF,MAAM,MAAM,GAAG,gBAAgB,CAAC,aAAa,CAAC,CAAC;IAE/C,OAAO;QACL,MAAM,CAAC,KAAK,EAAE,WAAW;YACvB,MAAM,UAAU,GAAG,oBAAoB,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;YAC7F,kEAAkE;YAClE,yEAAyE;YACzE,2EAA2E;YAC3E,uEAAuE;YACvE,0EAA0E;YAC1E,yEAAyE;YACzE,yEAAyE;YACzE,oDAAoD;YACpD,MAAM,OAAO,GAA2B;gBACtC,eAAe,EAAE,UAAU;gBAC3B,iBAAiB,EAAE,UAAU,EAAE;aAChC,CAAC;YACF,oEAAoE;YACpE,wEAAwE;YACxE,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,GAAG,qBAAqB,EAAE,CAAC;iBACvE,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE;gBACjB,sEAAsE;gBACtE,kEAAkE;gBAClE,MAAM,EAAE,GAAG,QAAQ,IAAI,QAAQ,CAAC,UAAU,IAAI,GAAG,IAAI,QAAQ,CAAC,UAAU,GAAG,GAAG,CAAC;gBAC/E,IAAI,CAAC,EAAE,EAAE,CAAC;oBACR,MAAM,CAAC,IAAI,CAAC,4BAA4B,EAAE;wBACxC,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU;qBACvD,CAAC,CAAC;gBACL,CAAC;YACH,CAAC,CAAC;iBACD,KAAK,CAAC,CAAC,GAAY,EAAE,EAAE;gBACtB,MAAM,CAAC,IAAI,CAAC,2BAA2B,EAAE;oBACvC,MAAM,EAAE,KAAK,CAAC,MAAM;oBACpB,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAA,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;iBACvD,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACP,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { randomUUID } from 'crypto';\nimport { createSafeClient, type RequestOptions } from './http-client.js';\nimport { getServiceAuthHeader } from '../middleware/auth.js';\nimport type { ServiceConfig } from '../types/common.js';\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('remote-audit');\n\n/**\n * Audit ingest is best-effort and MUST NOT block the caller, but a transient\n * failure (429 / 5xx / connection reset / timeout) should not silently drop the\n * row on the first attempt. Each emission carries a stable per-event\n * `Idempotency-Key` (see `record`), so the http-client treats the POST as\n * retry-safe and the platform can dedup a retried delivery instead of writing a\n * duplicate row. Budget is kept small so a hard-down platform can't back the\n * worker up for long: base delay ×(2 retries) + a couple of 429 backoffs.\n */\nconst AUDIT_REQUEST_OPTIONS: Pick<RequestOptions, 'maxRateLimitRetries' | 'maxRetries'> = {\n  maxRateLimitRetries: 2,\n  maxRetries: 2,\n};\n\n/**\n * Subset of platform's AuditAction enum that non-platform services emit.\n * Kept in sync manually with platform/src/models/audit-event.ts; mismatched\n * actions are rejected by the platform ingest endpoint (400) so a drift is\n * visible in logs rather than silently dropped.\n */\nexport type RemoteAuditAction =\n  | 'plugin.build.completed'\n  | 'plugin.build.failed'\n  | 'plugin.build.timeout'\n  // Plugin lifecycle mutations (api/plugin route handlers) — the destructive /\n  // publishing surface that builds already audit's counterpart: registry delete,\n  // source upload, and deploy-to-cluster. `targetId` is the plugin id.\n  | 'plugin.delete'\n  | 'plugin.upload'\n  | 'plugin.deploy'\n  // Pipeline mutations — emitted by api/pipeline's route handlers\n  // (create/update/delete + CodePipeline execution trigger/cancel) and\n  // posted to platform's `POST /audit/events` ingest.\n  | 'pipeline.create'\n  | 'pipeline.update'\n  | 'pipeline.delete'\n  | 'pipeline.execution.start'\n  | 'pipeline.execution.cancel'\n  // Quota administration (api/quota) — a superadmin resetting an org's usage\n  // counter or editing its tier limits. `affectedOrgId` is the org changed;\n  // `details` carries the quotaType + old/new value.\n  | 'quota.reset'\n  | 'quota.limit.update'\n  // Compliance rule administration (api/compliance) — approving an exemption\n  // request, toggling a rule active/inactive, or cancelling a running scan.\n  // `targetId` is the rule/exemption/scan id.\n  | 'compliance.exemption.approve'\n  | 'compliance.rule.toggle'\n  | 'compliance.scan.cancel'\n  // Image-registry destructive ops (api/image-registry) — garbage-collection\n  // sweeps and explicit image/tag deletes (previously only a log line).\n  | 'registry.gc'\n  | 'registry.image.delete'\n  // Denied authorization attempt — emitted best-effort by the shared\n  // `requirePermission` / `requireSystemAdmin` gate when a state-changing\n  // (non-GET) request is rejected, so probing/escalation attempts are visible\n  // rather than invisible. `details` carries the required permission + path;\n  // `outcome` is 'failure'.\n  | 'authz.denied';\n\nexport interface RemoteAuditEvent {\n  action: RemoteAuditAction;\n  actorId: string;\n  actorEmail?: string;\n  orgId?: string;\n  affectedOrgId?: string;\n  targetType?: string;\n  targetId?: string;\n  /**\n   * Did the audited action succeed or fail? Defaults to 'success' when omitted\n   * (the platform ingest applies the same default). Denied-authz events set\n   * 'failure' so a reviewer can filter attempts from completed actions.\n   */\n  outcome?: 'success' | 'failure';\n  details?: Record<string, unknown>;\n}\n\n/**\n * Client for POSTing audit events to the platform's `/audit-events` ingest\n * endpoint. Mints a fresh service token per call (5 min TTL)  there's no\n * meaningful caching benefit when emissions are sparse.\n */\nexport interface RemoteAuditClient {\n  /**\n   * Fire-and-forget audit emission. Failures are logged at warn level but\n   * never thrown  the originating action (e.g. a plugin build) has its\n   * own success/failure path that shouldn't get polluted by a flaky audit\n   * downstream.\n   */\n  record(event: RemoteAuditEvent, serviceName: string): void;\n}\n\n/**\n * Configuration for the remote audit client.\n */\nexport interface RemoteAuditClientConfig {\n  /** Platform service host (default: env PLATFORM_SERVICE_HOST or 'platform') */\n  host?: string;\n  /** Platform service port (default: env PLATFORM_SERVICE_PORT or 3000) */\n  port?: number;\n  /** Request timeout ms (default 3000  audit shouldn't block the worker). */\n  timeout?: number;\n}\n\n/**\n * Construct a remote-audit client targeted at the platform service.\n *\n * Used by api/plugin's build worker to push `plugin.build.*` events into\n * the platform's MongoDB `audit_events` collection. Other services\n * with worker-style emitters can use the same client.\n *\n * @example\n * ```typescript\n * const auditClient = createRemoteAuditClient();\n * auditClient.record({\n * action: 'plugin.build.completed',\n * actorId: 'user-123',\n * orgId: 'org-acme',\n * targetType: 'plugin',\n * targetId: 'plugin-abc',\n * details: { name: 'my-plugin', version: '1.0.0' },\n * }, 'plugin');\n * ```\n */\nexport function createRemoteAuditClient(config: RemoteAuditClientConfig = {}): RemoteAuditClient {\n  const serviceConfig: ServiceConfig = {\n    host: config.host ?? process.env.PLATFORM_SERVICE_HOST ?? 'platform',\n    port: config.port ?? parseInt(process.env.PLATFORM_SERVICE_PORT ?? '3000', 10),\n    timeout: config.timeout ?? 3000,\n  };\n  const client = createSafeClient(serviceConfig);\n\n  return {\n    record(event, serviceName) {\n      const authHeader = getServiceAuthHeader({ serviceName, orgId: event.orgId, role: 'member' });\n      // getServiceAuthHeader returns a full `Bearer <token>` value; the\n      // http-client forwards request headers as-is (it does NOT inject its own\n      // Authorization), so pass it straight through as the Authorization header.\n      // A stable per-emission Idempotency-Key makes this non-idempotent POST\n      // retry-safe in the http-client (so transient 5xx/timeout/429 are retried\n      // rather than dropped) and lets the platform ingest dedup a re-delivered\n      // event instead of writing a duplicate audit row. Generated once here so\n      // every retry of THIS emission reuses the same key.\n      const headers: Record<string, string> = {\n        'Authorization': authHeader,\n        'Idempotency-Key': randomUUID(),\n      };\n      // Path is /audit/events  the platform mounts the audit router under\n      // /audit, and the internal ingest endpoint lives at /events under that.\n      client.post('/audit/events', event, { headers, ...AUDIT_REQUEST_OPTIONS })\n        .then((response) => {\n          // Any 2xx is an accept (the ingest returns 200 today, but 201/202/204\n          // are equally \"stored\"); only a non-2xx / missing response warns.\n          const ok = response && response.statusCode >= 200 && response.statusCode < 300;\n          if (!ok) {\n            logger.warn('Remote audit ingest non-ok', {\n              action: event.action, statusCode: response?.statusCode,\n            });\n          }\n        })\n        .catch((err: unknown) => {\n          logger.warn('Remote audit ingest threw', {\n            action: event.action,\n            error: err instanceof Error ? err.message: String(err),\n          });\n        });\n    },\n  };\n}\n"]}

package/lib/services/token-revocation.d.ts

@@ -0,0 +1,37 @@
+import type { RedisCacheClient } from './cache-service.js';
+import type { TokenRevocationStore } from '../middleware/auth.js';
+/**
+ * Redis key namespace for the per-user current `tokenVersion`. The platform
+ * PUBLISHES to this key on every privilege change; the stateless services READ
+ * it in `requireAuth` (via {@link createRedisTokenRevocationStore}) to reject
+ * tokens minted before that change. Publisher and readers MUST share this exact
+ * prefix — hence both helpers live here, in one place.
+ */
+export declare const TOKEN_REVOCATION_KEY_PREFIX = "authrev:tv:";
+/** The revocation key for a user id. */
+export declare function tokenRevocationKey(userId: string): string;
+/**
+ * Build a {@link TokenRevocationStore} backed by a Redis client, for a stateless
+ * service to register via `setTokenRevocationStore`. Reads the current
+ * `tokenVersion` the platform published for the user.
+ *
+ * Fail-open by contract: a miss, a parse failure, or a Redis error all yield
+ * `null` (— `requireAuth` treats that as "no known revocation"), so a Redis
+ * outage degrades to the pre-existing behaviour rather than locking users out.
+ */
+export declare function createRedisTokenRevocationStore(redis: RedisCacheClient): TokenRevocationStore;
+/**
+ * Publish a user's current `tokenVersion` so the stateless services see the
+ * revocation immediately (platform side). Best-effort — never throws; a failure
+ * just means the services fall back to natural token expiry for this change.
+ *
+ * The key is written with a TTL equal to the access-token lifetime: any token
+ * that could still carry an older version has expired by the time the entry
+ * lapses, so an expired entry can never cause a false "revoked" nor a missed one.
+ *
+ * @param redis - the platform's Redis client
+ * @param userId - the user whose sessions changed
+ * @param tokenVersion - the user's NEW (post-increment) tokenVersion
+ * @param ttlSeconds - access-token lifetime in seconds
+ */
+export declare function publishTokenRevocation(redis: RedisCacheClient, userId: string, tokenVersion: number, ttlSeconds: number): Promise<void>;

package/lib/services/token-revocation.js

@@ -0,0 +1,74 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createLogger } from '../utils/logger.js';
+const logger = createLogger('token-revocation');
+/**
+ * Redis key namespace for the per-user current `tokenVersion`. The platform
+ * PUBLISHES to this key on every privilege change; the stateless services READ
+ * it in `requireAuth` (via {@link createRedisTokenRevocationStore}) to reject
+ * tokens minted before that change. Publisher and readers MUST share this exact
+ * prefix — hence both helpers live here, in one place.
+ */
+export const TOKEN_REVOCATION_KEY_PREFIX = 'authrev:tv:';
+/** The revocation key for a user id. */
+export function tokenRevocationKey(userId) {
+    return `${TOKEN_REVOCATION_KEY_PREFIX}${userId}`;
+}
+/**
+ * Build a {@link TokenRevocationStore} backed by a Redis client, for a stateless
+ * service to register via `setTokenRevocationStore`. Reads the current
+ * `tokenVersion` the platform published for the user.
+ *
+ * Fail-open by contract: a miss, a parse failure, or a Redis error all yield
+ * `null` (— `requireAuth` treats that as "no known revocation"), so a Redis
+ * outage degrades to the pre-existing behaviour rather than locking users out.
+ */
+export function createRedisTokenRevocationStore(redis) {
+    return {
+        async getCurrentVersion(userId) {
+            try {
+                const raw = await redis.get(tokenRevocationKey(userId));
+                if (raw === null || raw === undefined || raw.trim() === '')
+                    return null;
+                // Strict integer parse: `Number` (unlike `parseInt`) rejects trailing
+                // garbage ("5abc" → NaN), so a corrupted entry fails open (null → "not
+                // revoked") rather than being read as a bogus version. The empty-string
+                // guard above matters because `Number('')` is 0, not NaN.
+                const n = Number(raw);
+                return Number.isInteger(n) ? n : null;
+            }
+            catch (err) {
+                logger.debug('Token-revocation read failed (fail-open)', {
+                    userId, error: err instanceof Error ? err.message : String(err),
+                });
+                return null;
+            }
+        },
+    };
+}
+/**
+ * Publish a user's current `tokenVersion` so the stateless services see the
+ * revocation immediately (platform side). Best-effort — never throws; a failure
+ * just means the services fall back to natural token expiry for this change.
+ *
+ * The key is written with a TTL equal to the access-token lifetime: any token
+ * that could still carry an older version has expired by the time the entry
+ * lapses, so an expired entry can never cause a false "revoked" nor a missed one.
+ *
+ * @param redis - the platform's Redis client
+ * @param userId - the user whose sessions changed
+ * @param tokenVersion - the user's NEW (post-increment) tokenVersion
+ * @param ttlSeconds - access-token lifetime in seconds
+ */
+export async function publishTokenRevocation(redis, userId, tokenVersion, ttlSeconds) {
+    try {
+        // ioredis-style variadic SET with expiry: SET key val EX ttl.
+        await redis.set(tokenRevocationKey(userId), String(tokenVersion), 'EX', Math.max(1, Math.floor(ttlSeconds)));
+    }
+    catch (err) {
+        logger.warn('Token-revocation publish failed (services fall back to token expiry)', {
+            userId, error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types/common.d.ts

@@ -184,7 +184,8 @@ export interface JwtPayload {
      * Org → team hierarchy (org-team-hierarchy proposal, phase 1).
      * `parentOrganizationId` is the active org's direct parent; `rootOrganizationId`
      * is the top of its ancestry chain. Both are **omitted for flat (root) orgs** —
-     * consumers should treat the effective root as `rootOrganizationId ?? organizationId`.
+     * consumers should treat the effective root as `rootOrganizationId ?? organizationId`
+     * (use the shared {@link effectiveRootOrgId} accessor rather than coalescing inline).
      * Currently every org is flat, so these are absent on all tokens today.
      */
     parentOrganizationId?: string;
@@ -202,6 +203,16 @@ export interface JwtPayload {
      * sysadmins "view as user X" without risking a destructive action.
      */
     impersonationReadOnly?: boolean;
+    /**
+     * The user's `tokenVersion` at the moment this token was issued. Every
+     * privilege change (deactivate / role or tier downgrade / membership or
+     * ownership change / password change / logout-all) increments the user's
+     * server-side `tokenVersion`, so a token whose embedded version is behind the
+     * current one has been REVOKED. Platform validates this against Mongo; the
+     * stateless services validate it against a Redis-published current-version
+     * store (see `setTokenRevocationStore`). Absent on machine/service tokens.
+     */
+    tokenVersion?: number;
     /** Token type */
     type: 'access' | 'refresh';
     /** Issued at timestamp */
@@ -209,6 +220,19 @@ export interface JwtPayload {
     /** Expiration timestamp */
     exp?: number;
 }
+/**
+ * The account boundary (root org) for a token's active org.
+ *
+ * The account root is `rootOrganizationId ?? organizationId`: a flat (root) org
+ * omits `rootOrganizationId`, so it IS its own root; a team (child) org carries
+ * the top of its ancestry chain. Every account-scoped read (quota/seat/billing
+ * pooling) must resolve through this coalesce rather than reading
+ * `organizationId` directly — the latter silently works today (all orgs flat)
+ * but would bind to the team instead of the account once teams exist.
+ *
+ * @returns the effective root org id, or `undefined` when neither field is set.
+ */
+export declare function effectiveRootOrgId(payload: Pick<JwtPayload, 'organizationId' | 'rootOrganizationId'>): string | undefined;
 /**
  * Extended Express Request with user property.
  */

package/lib/types/common.js

@@ -48,4 +48,19 @@ export function validateQuotaType(value, fieldName = 'quotaType') {
     }
     return value;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAgCtC;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc;IAC7D,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,YAAY;CACrD,CAAC;AAEX;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,iBAAiB,CAAC,QAAQ,CAAC,KAAkB,CAAC,CAAC;AACrF,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAc,EAAE,SAAS,GAAG,WAAW;IACvE,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CACb,WAAW,SAAS,MAAM,KAAK,sBAAsB,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACpF,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Permission } from './permissions.js';\n\n/**\n * Quota type identifiers.\n *\n * - `plugins` / `pipelines` — count of created entities\n * - `apiCalls` — generic API call count (read-heavy paths)\n * - `aiCalls` — AI provider invocations (counted separately because each call\n *   has external dollar cost; sized smaller than apiCalls per tier)\n * - `storageBytes` — registry storage budget per org. Unlike the others\n *   (which count discrete events), this is a measured total recomputed\n *   on demand. Incremented by the image-registry's push-gate before\n *   issuing a token whose scope includes `push`; the GC scheduler\n *   eventually frees the bytes, then the next push-gate check reads\n *   the lower value. NOT a counter-style quota in the sense of\n *   `incrementUsage` — the registry pushes the measured total via\n *   `updateLimits`/`resetUsage` flows. Tier limits are bytes.\n * - `dashboards` / `alertRules` / `alertDestinations` / `idpConfigs` —\n *   resource-count quotas added to close per-org DoS surfaces in the\n *   user-editable feature tables. Without these caps a single org could\n *   spam thousands of dashboards / rules and bloat the shared Postgres /\n *   Mongo working sets. Counted at create time; decremented on delete.\n */\n// NOTE: `seats` is intentionally NOT here. It's a tier limit (QuotaTierLimits)\n// enforced by comparing the org's LIVE member count at invite time — not an\n// incrementing per-period counter like the consumable quotas below.\nexport type QuotaType =\n  | 'plugins' | 'pipelines' | 'apiCalls' | 'aiCalls' | 'storageBytes'\n  | 'dashboards' | 'alertRules' | 'alertDestinations' | 'idpConfigs';\n\n/**\n * Valid quota type values.\n */\nexport const VALID_QUOTA_TYPES = [\n  'plugins', 'pipelines', 'apiCalls', 'aiCalls', 'storageBytes',\n  'dashboards', 'alertRules', 'alertDestinations', 'idpConfigs',\n] as const;\n\n/**\n * Type guard to check if a value is a valid QuotaType.\n *\n * @param value - Value to check\n * @returns True if value is a valid QuotaType\n *\n * @example\n * ```typescript\n * if (isValidQuotaType(req.body.quotaType)) {\n *   // quotaType is guaranteed to be QuotaType\n * }\n * ```\n */\nexport function isValidQuotaType(value: unknown): value is QuotaType {\n  return typeof value === 'string' && VALID_QUOTA_TYPES.includes(value as QuotaType);\n}\n\n/**\n * Validate and assert that a value is a valid QuotaType.\n * Throws an error if validation fails.\n *\n * @param value - Value to validate\n * @param fieldName - Name of the field being validated (for error messages)\n * @returns The validated QuotaType\n * @throws Error if value is not a valid QuotaType\n *\n * @example\n * ```typescript\n * try {\n *   const quotaType = validateQuotaType(req.body.quotaType, 'quotaType');\n *   // Use quotaType safely\n * } catch (err) {\n *   return sendError(res, 400, err.message);\n * }\n * ```\n */\nexport function validateQuotaType(value: unknown, fieldName = 'quotaType'): QuotaType {\n  if (!isValidQuotaType(value)) {\n    throw new Error(\n      `Invalid ${fieldName}: \"${value}\". Must be one of: ${VALID_QUOTA_TYPES.join(', ')}`,\n    );\n  }\n  return value;\n}\n\n/**\n * Result from quota check operation.\n */\nexport interface QuotaCheckResult {\n  /** Whether the request is allowed */\n  allowed: boolean;\n  /** Maximum quota limit (-1 for unlimited) */\n  limit: number;\n  /** Current usage count */\n  used: number;\n  /** Remaining quota (-1 for unlimited) */\n  remaining: number;\n  /** ISO timestamp when quota resets */\n  resetAt: string;\n  /** Whether quota is unlimited */\n  unlimited: boolean;\n  /**\n   * True ONLY when this result is the fail-open sentinel returned because the\n   * quota service was unreachable / returned non-ok (not a real quota reading).\n   * Lets fail-closed callers (e.g. the registry storage push-gate) distinguish\n   * an outage from a genuine `limit: -1` (unlimited) org. Absent on real results.\n   */\n  failOpen?: boolean;\n}\n\n/**\n * Quota information for error responses.\n */\nexport interface QuotaInfo {\n  type: QuotaType;\n  limit: number;\n  used: number;\n  remaining: number;\n}\n\n/**\n * Standard API success response.\n */\nexport interface ApiSuccessResponse<T = unknown> {\n  success: true;\n  statusCode: number;\n  data?: T;\n  message?: string;\n}\n\n/**\n * Standard API error response.\n */\nexport interface ApiErrorResponse {\n  success: false;\n  statusCode: number;\n  message: string;\n  code?: string;\n  details?: unknown;\n  quota?: QuotaInfo;\n}\n\n/**\n * Combined API response type.\n */\nexport type ApiResponse<T = unknown> = ApiSuccessResponse<T> | ApiErrorResponse;\n\n/**\n * JWT payload from access tokens.\n *\n * Users can belong to multiple organizations. The token is scoped to one\n * active organization at a time. The `role` field is the user's per-org\n * role in that organization (from the UserOrganization junction collection),\n * and `isAdmin` is derived as `role === 'admin' || role === 'owner'`.\n *\n * Use `POST /auth/switch-org` to change the active organization, which\n * re-issues tokens with the new org's role and context.\n */\n/**\n * Coarse per-org membership label, DERIVED from the Roles a user is assigned\n * (the highest `grantsRole` among them; `owner` is set only by ownership\n * transfer). It is a display/authority label — driving `isAdmin`, ownership,\n * and seat accounting — NOT a permission source. Effective permissions come\n * solely from the user's assigned Roles (see `resolveUserPermissions`). Not a\n * global role.\n */\nexport type OrgRole = 'owner' | 'admin' | 'member';\n\nexport interface JwtPayload {\n  /** User ID (subject) */\n  sub: string;\n  /** Username */\n  username: string;\n  /** User email */\n  email: string;\n  /** Per-org role in the active organization ('owner' | 'admin' | 'member'). Not a global role. */\n  role: OrgRole;\n  /** Derived: true when role is 'admin' or 'owner' in the active organization */\n  isAdmin?: boolean;\n  /**\n   * Resolved fine-grained permissions for the active org/team — the union of\n   * the permissions carried by every Role the user is assigned (see\n   * `resolveUserPermissions`). Absent on machine/scoped tokens. Superadmins are\n   * granted all permissions implicitly and may omit this. Endpoints enforce via\n   * `requirePermission(...)`.\n   */\n  permissions?: Permission[];\n  /**\n   * Global super-admin flag (cross-org). When `true`, the user is treated\n   * as a system administrator regardless of which org they're currently\n   * acting under. This is the canonical signal for sysadmin authority —\n   * previously the only path was membership in the well-known \"system\" org\n   * with role admin/owner, which conflated \"Pipeline Builder operator\" with\n   * \"real customer tenant\" in the data model. Either path still works\n   * during the rollout; new users should be granted via `isSuperAdmin`.\n   */\n  isSuperAdmin?: boolean;\n  /** Organization's quota tier ('developer' | 'pro' | 'team' | 'enterprise') */\n  tier?: string;\n  /** Resolved feature flags for this user/org */\n  features?: string[];\n  /**\n   * Narrow capability scope for machine/automation tokens (e.g.\n   * `'reporting:ingest'`). Absent on normal interactive user tokens. Endpoints\n   * that accept a scoped identity check this (see `hasScope`) instead of role;\n   * a scoped token is minted with minimal role for least-privilege.\n   */\n  scope?: string;\n  /** Active organization ID (from UserOrganization membership) */\n  organizationId?: string;\n  /** Active organization name */\n  organizationName?: string;\n  /**\n   * Org → team hierarchy (org-team-hierarchy proposal, phase 1).\n   * `parentOrganizationId` is the active org's direct parent; `rootOrganizationId`\n   * is the top of its ancestry chain. Both are **omitted for flat (root) orgs** —\n   * consumers should treat the effective root as `rootOrganizationId ?? organizationId`.\n   * Currently every org is flat, so these are absent on all tokens today.\n   */\n  parentOrganizationId?: string;\n  /** Root organization ID of the active org's ancestry chain (see `parentOrganizationId`). */\n  rootOrganizationId?: string;\n  /**\n   * Set on tokens issued by the sysadmin impersonation flow\n   * (`POST /admin/impersonate/:userId`). Carries the original sysadmin's\n   * user id so audit events still attribute actions correctly.\n   */\n  impersonatorId?: string;\n  /**\n   * When true, the token is read-only — any non-GET request is rejected\n   * upstream by the platform's read-only impersonation gate. Lets\n   * sysadmins \"view as user X\" without risking a destructive action.\n   */\n  impersonationReadOnly?: boolean;\n  /** Token type */\n  type: 'access' | 'refresh';\n  /** Issued at timestamp */\n  iat?: number;\n  /** Expiration timestamp */\n  exp?: number;\n}\n\n/**\n * Extended Express Request with user property.\n */\ndeclare global {\n  namespace Express {\n    interface Request {\n      user?: JwtPayload;\n    }\n  }\n}\n\n/**\n * Service configuration for internal HTTP client.\n */\nexport interface ServiceConfig {\n  /** Service hostname */\n  host: string;\n  /** Service port */\n  port: number;\n  /** Request timeout in milliseconds */\n  timeout?: number;\n}\n\n/**\n * Health check response.\n */\nexport interface HealthCheckResponse {\n  status: 'healthy' | 'unhealthy';\n  service: string;\n  timestamp: string;\n  uptime: number;\n  version?: string;\n  dependencies?: Record<string, 'connected' | 'disconnected' | 'unknown'>;\n}\n"]}
+/**
+ * The account boundary (root org) for a token's active org.
+ *
+ * The account root is `rootOrganizationId ?? organizationId`: a flat (root) org
+ * omits `rootOrganizationId`, so it IS its own root; a team (child) org carries
+ * the top of its ancestry chain. Every account-scoped read (quota/seat/billing
+ * pooling) must resolve through this coalesce rather than reading
+ * `organizationId` directly — the latter silently works today (all orgs flat)
+ * but would bind to the team instead of the account once teams exist.
+ *
+ * @returns the effective root org id, or `undefined` when neither field is set.
+ */
+export function effectiveRootOrgId(payload) {
+    return payload.rootOrganizationId ?? payload.organizationId;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAgCtC;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc;IAC7D,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,YAAY;CACrD,CAAC;AAEX;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,iBAAiB,CAAC,QAAQ,CAAC,KAAkB,CAAC,CAAC;AACrF,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAc,EAAE,SAAS,GAAG,WAAW;IACvE,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CACb,WAAW,SAAS,MAAM,KAAK,sBAAsB,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACpF,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AA0KD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,kBAAkB,CAChC,OAAkE;IAElE,OAAO,OAAO,CAAC,kBAAkB,IAAI,OAAO,CAAC,cAAc,CAAC;AAC9D,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Permission } from './permissions.js';\n\n/**\n * Quota type identifiers.\n *\n * - `plugins` / `pipelines` — count of created entities\n * - `apiCalls` — generic API call count (read-heavy paths)\n * - `aiCalls` — AI provider invocations (counted separately because each call\n *   has external dollar cost; sized smaller than apiCalls per tier)\n * - `storageBytes` — registry storage budget per org. Unlike the others\n *   (which count discrete events), this is a measured total recomputed\n *   on demand. Incremented by the image-registry's push-gate before\n *   issuing a token whose scope includes `push`; the GC scheduler\n *   eventually frees the bytes, then the next push-gate check reads\n *   the lower value. NOT a counter-style quota in the sense of\n *   `incrementUsage` — the registry pushes the measured total via\n *   `updateLimits`/`resetUsage` flows. Tier limits are bytes.\n * - `dashboards` / `alertRules` / `alertDestinations` / `idpConfigs` —\n *   resource-count quotas added to close per-org DoS surfaces in the\n *   user-editable feature tables. Without these caps a single org could\n *   spam thousands of dashboards / rules and bloat the shared Postgres /\n *   Mongo working sets. Counted at create time; decremented on delete.\n */\n// NOTE: `seats` is intentionally NOT here. It's a tier limit (QuotaTierLimits)\n// enforced by comparing the org's LIVE member count at invite time — not an\n// incrementing per-period counter like the consumable quotas below.\nexport type QuotaType =\n  | 'plugins' | 'pipelines' | 'apiCalls' | 'aiCalls' | 'storageBytes'\n  | 'dashboards' | 'alertRules' | 'alertDestinations' | 'idpConfigs';\n\n/**\n * Valid quota type values.\n */\nexport const VALID_QUOTA_TYPES = [\n  'plugins', 'pipelines', 'apiCalls', 'aiCalls', 'storageBytes',\n  'dashboards', 'alertRules', 'alertDestinations', 'idpConfigs',\n] as const;\n\n/**\n * Type guard to check if a value is a valid QuotaType.\n *\n * @param value - Value to check\n * @returns True if value is a valid QuotaType\n *\n * @example\n * ```typescript\n * if (isValidQuotaType(req.body.quotaType)) {\n *   // quotaType is guaranteed to be QuotaType\n * }\n * ```\n */\nexport function isValidQuotaType(value: unknown): value is QuotaType {\n  return typeof value === 'string' && VALID_QUOTA_TYPES.includes(value as QuotaType);\n}\n\n/**\n * Validate and assert that a value is a valid QuotaType.\n * Throws an error if validation fails.\n *\n * @param value - Value to validate\n * @param fieldName - Name of the field being validated (for error messages)\n * @returns The validated QuotaType\n * @throws Error if value is not a valid QuotaType\n *\n * @example\n * ```typescript\n * try {\n *   const quotaType = validateQuotaType(req.body.quotaType, 'quotaType');\n *   // Use quotaType safely\n * } catch (err) {\n *   return sendError(res, 400, err.message);\n * }\n * ```\n */\nexport function validateQuotaType(value: unknown, fieldName = 'quotaType'): QuotaType {\n  if (!isValidQuotaType(value)) {\n    throw new Error(\n      `Invalid ${fieldName}: \"${value}\". Must be one of: ${VALID_QUOTA_TYPES.join(', ')}`,\n    );\n  }\n  return value;\n}\n\n/**\n * Result from quota check operation.\n */\nexport interface QuotaCheckResult {\n  /** Whether the request is allowed */\n  allowed: boolean;\n  /** Maximum quota limit (-1 for unlimited) */\n  limit: number;\n  /** Current usage count */\n  used: number;\n  /** Remaining quota (-1 for unlimited) */\n  remaining: number;\n  /** ISO timestamp when quota resets */\n  resetAt: string;\n  /** Whether quota is unlimited */\n  unlimited: boolean;\n  /**\n   * True ONLY when this result is the fail-open sentinel returned because the\n   * quota service was unreachable / returned non-ok (not a real quota reading).\n   * Lets fail-closed callers (e.g. the registry storage push-gate) distinguish\n   * an outage from a genuine `limit: -1` (unlimited) org. Absent on real results.\n   */\n  failOpen?: boolean;\n}\n\n/**\n * Quota information for error responses.\n */\nexport interface QuotaInfo {\n  type: QuotaType;\n  limit: number;\n  used: number;\n  remaining: number;\n}\n\n/**\n * Standard API success response.\n */\nexport interface ApiSuccessResponse<T = unknown> {\n  success: true;\n  statusCode: number;\n  data?: T;\n  message?: string;\n}\n\n/**\n * Standard API error response.\n */\nexport interface ApiErrorResponse {\n  success: false;\n  statusCode: number;\n  message: string;\n  code?: string;\n  details?: unknown;\n  quota?: QuotaInfo;\n}\n\n/**\n * Combined API response type.\n */\nexport type ApiResponse<T = unknown> = ApiSuccessResponse<T> | ApiErrorResponse;\n\n/**\n * JWT payload from access tokens.\n *\n * Users can belong to multiple organizations. The token is scoped to one\n * active organization at a time. The `role` field is the user's per-org\n * role in that organization (from the UserOrganization junction collection),\n * and `isAdmin` is derived as `role === 'admin' || role === 'owner'`.\n *\n * Use `POST /auth/switch-org` to change the active organization, which\n * re-issues tokens with the new org's role and context.\n */\n/**\n * Coarse per-org membership label, DERIVED from the Roles a user is assigned\n * (the highest `grantsRole` among them; `owner` is set only by ownership\n * transfer). It is a display/authority label — driving `isAdmin`, ownership,\n * and seat accounting — NOT a permission source. Effective permissions come\n * solely from the user's assigned Roles (see `resolveUserPermissions`). Not a\n * global role.\n */\nexport type OrgRole = 'owner' | 'admin' | 'member';\n\nexport interface JwtPayload {\n  /** User ID (subject) */\n  sub: string;\n  /** Username */\n  username: string;\n  /** User email */\n  email: string;\n  /** Per-org role in the active organization ('owner' | 'admin' | 'member'). Not a global role. */\n  role: OrgRole;\n  /** Derived: true when role is 'admin' or 'owner' in the active organization */\n  isAdmin?: boolean;\n  /**\n   * Resolved fine-grained permissions for the active org/team — the union of\n   * the permissions carried by every Role the user is assigned (see\n   * `resolveUserPermissions`). Absent on machine/scoped tokens. Superadmins are\n   * granted all permissions implicitly and may omit this. Endpoints enforce via\n   * `requirePermission(...)`.\n   */\n  permissions?: Permission[];\n  /**\n   * Global super-admin flag (cross-org). When `true`, the user is treated\n   * as a system administrator regardless of which org they're currently\n   * acting under. This is the canonical signal for sysadmin authority —\n   * previously the only path was membership in the well-known \"system\" org\n   * with role admin/owner, which conflated \"Pipeline Builder operator\" with\n   * \"real customer tenant\" in the data model. Either path still works\n   * during the rollout; new users should be granted via `isSuperAdmin`.\n   */\n  isSuperAdmin?: boolean;\n  /** Organization's quota tier ('developer' | 'pro' | 'team' | 'enterprise') */\n  tier?: string;\n  /** Resolved feature flags for this user/org */\n  features?: string[];\n  /**\n   * Narrow capability scope for machine/automation tokens (e.g.\n   * `'reporting:ingest'`). Absent on normal interactive user tokens. Endpoints\n   * that accept a scoped identity check this (see `hasScope`) instead of role;\n   * a scoped token is minted with minimal role for least-privilege.\n   */\n  scope?: string;\n  /** Active organization ID (from UserOrganization membership) */\n  organizationId?: string;\n  /** Active organization name */\n  organizationName?: string;\n  /**\n   * Org → team hierarchy (org-team-hierarchy proposal, phase 1).\n   * `parentOrganizationId` is the active org's direct parent; `rootOrganizationId`\n   * is the top of its ancestry chain. Both are **omitted for flat (root) orgs** —\n   * consumers should treat the effective root as `rootOrganizationId ?? organizationId`\n   * (use the shared {@link effectiveRootOrgId} accessor rather than coalescing inline).\n   * Currently every org is flat, so these are absent on all tokens today.\n   */\n  parentOrganizationId?: string;\n  /** Root organization ID of the active org's ancestry chain (see `parentOrganizationId`). */\n  rootOrganizationId?: string;\n  /**\n   * Set on tokens issued by the sysadmin impersonation flow\n   * (`POST /admin/impersonate/:userId`). Carries the original sysadmin's\n   * user id so audit events still attribute actions correctly.\n   */\n  impersonatorId?: string;\n  /**\n   * When true, the token is read-only — any non-GET request is rejected\n   * upstream by the platform's read-only impersonation gate. Lets\n   * sysadmins \"view as user X\" without risking a destructive action.\n   */\n  impersonationReadOnly?: boolean;\n  /**\n   * The user's `tokenVersion` at the moment this token was issued. Every\n   * privilege change (deactivate / role or tier downgrade / membership or\n   * ownership change / password change / logout-all) increments the user's\n   * server-side `tokenVersion`, so a token whose embedded version is behind the\n   * current one has been REVOKED. Platform validates this against Mongo; the\n   * stateless services validate it against a Redis-published current-version\n   * store (see `setTokenRevocationStore`). Absent on machine/service tokens.\n   */\n  tokenVersion?: number;\n  /** Token type */\n  type: 'access' | 'refresh';\n  /** Issued at timestamp */\n  iat?: number;\n  /** Expiration timestamp */\n  exp?: number;\n}\n\n/**\n * The account boundary (root org) for a token's active org.\n *\n * The account root is `rootOrganizationId ?? organizationId`: a flat (root) org\n * omits `rootOrganizationId`, so it IS its own root; a team (child) org carries\n * the top of its ancestry chain. Every account-scoped read (quota/seat/billing\n * pooling) must resolve through this coalesce rather than reading\n * `organizationId` directly — the latter silently works today (all orgs flat)\n * but would bind to the team instead of the account once teams exist.\n *\n * @returns the effective root org id, or `undefined` when neither field is set.\n */\nexport function effectiveRootOrgId(\n  payload: Pick<JwtPayload, 'organizationId' | 'rootOrganizationId'>,\n): string | undefined {\n  return payload.rootOrganizationId ?? payload.organizationId;\n}\n\n/**\n * Extended Express Request with user property.\n */\ndeclare global {\n  namespace Express {\n    interface Request {\n      user?: JwtPayload;\n    }\n  }\n}\n\n/**\n * Service configuration for internal HTTP client.\n */\nexport interface ServiceConfig {\n  /** Service hostname */\n  host: string;\n  /** Service port */\n  port: number;\n  /** Request timeout in milliseconds */\n  timeout?: number;\n}\n\n/**\n * Health check response.\n */\nexport interface HealthCheckResponse {\n  status: 'healthy' | 'unhealthy';\n  service: string;\n  timestamp: string;\n  uptime: number;\n  version?: string;\n  dependencies?: Record<string, 'connected' | 'disconnected' | 'unknown'>;\n}\n"]}

package/lib/types/error-codes.d.ts

@@ -11,6 +11,7 @@ export declare enum ErrorCode {
     TOKEN_EXPIRED = "TOKEN_EXPIRED",
     TOKEN_INVALID = "TOKEN_INVALID",
     TOKEN_MISSING = "TOKEN_MISSING",
+    TOKEN_REVOKED = "TOKEN_REVOKED",
     INSUFFICIENT_PERMISSIONS = "INSUFFICIENT_PERMISSIONS",
     ORG_MISMATCH = "ORG_MISMATCH",
     COMPLIANCE_VIOLATION = "COMPLIANCE_VIOLATION",

package/lib/types/error-codes.js

@@ -15,6 +15,7 @@ export var ErrorCode;
     ErrorCode["TOKEN_EXPIRED"] = "TOKEN_EXPIRED";
     ErrorCode["TOKEN_INVALID"] = "TOKEN_INVALID";
     ErrorCode["TOKEN_MISSING"] = "TOKEN_MISSING";
+    ErrorCode["TOKEN_REVOKED"] = "TOKEN_REVOKED";
     // Authorization errors (403)
     ErrorCode["INSUFFICIENT_PERMISSIONS"] = "INSUFFICIENT_PERMISSIONS";
     ErrorCode["ORG_MISMATCH"] = "ORG_MISMATCH";
@@ -57,6 +58,7 @@ export const ErrorCodeStatus = {
     [ErrorCode.TOKEN_EXPIRED]: 401,
     [ErrorCode.TOKEN_INVALID]: 401,
     [ErrorCode.TOKEN_MISSING]: 401,
+    [ErrorCode.TOKEN_REVOKED]: 401,
     [ErrorCode.INSUFFICIENT_PERMISSIONS]: 403,
     [ErrorCode.ORG_MISMATCH]: 403,
     [ErrorCode.COMPLIANCE_VIOLATION]: 403,
@@ -89,4 +91,4 @@ export const ErrorCodeStatus = {
 export function getStatusForErrorCode(code) {
     return ErrorCodeStatus[code] ?? 500;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types/feature-flags.d.ts

@@ -21,11 +21,19 @@ export declare const FEATURE_METADATA: Record<FeatureFlag, {
  * 4. Invalid override keys are silently ignored.
  *
  * @param tier - The organization's quota tier
- * @param featureOverrides - Per-user overrides (key = feature flag, value = enabled)
- * @param isSuperAdmin - Whether the user has the global super-admin flag
+ * @param opts - Resolution options:
+ *   - `overrides`: per-user overrides (key = feature flag, value = enabled)
+ *   - `isSuperAdmin`: whether the user has the global super-admin flag
+ *   - `accountFeatures`: account-level entitlements (e.g. purchased add-on
+ *     bundles). A NAMED field so it can never be silently dropped by a caller
+ *     that omits a trailing positional arg.
  * @returns Sorted array of enabled feature flags
  */
-export declare function resolveUserFeatures(tier: QuotaTier, featureOverrides?: Record<string, boolean> | null, isSuperAdmin?: boolean, accountFeatures?: readonly string[] | null): FeatureFlag[];
+export declare function resolveUserFeatures(tier: QuotaTier, opts?: {
+    overrides?: Record<string, boolean> | null;
+    isSuperAdmin?: boolean;
+    accountFeatures?: readonly string[] | null;
+}): FeatureFlag[];
 /**
  * Check if a specific feature is enabled for a user. Delegates to
  * {@link resolveUserFeatures} so it stays in lockstep — including account-level

package/lib/types/feature-flags.js

@@ -18,9 +18,9 @@ export function isValidFeatureFlag(value) {
 export const TIER_FEATURES = {
     developer: [],
     pro: ['priority_support', 'ai_generation', 'bulk_operations'],
-    // Team adds audit_log (collaboration/governance); Enterprise unlocks all,
-    // including custom_integrations.
-    team: ['priority_support', 'ai_generation', 'bulk_operations', 'audit_log'],
+    // Team adds audit_log (collaboration/governance) and sso (SSO/IdP is INCLUDED
+    // in Team, not an add-on); Enterprise unlocks all, incl. custom_integrations.
+    team: ['priority_support', 'ai_generation', 'bulk_operations', 'audit_log', 'sso'],
     enterprise: [...ALL_FEATURE_FLAGS],
 };
 // Feature metadata (for display)
@@ -61,11 +61,16 @@ export const FEATURE_METADATA = {
  * 4. Invalid override keys are silently ignored.
  *
  * @param tier - The organization's quota tier
- * @param featureOverrides - Per-user overrides (key = feature flag, value = enabled)
- * @param isSuperAdmin - Whether the user has the global super-admin flag
+ * @param opts - Resolution options:
+ *   - `overrides`: per-user overrides (key = feature flag, value = enabled)
+ *   - `isSuperAdmin`: whether the user has the global super-admin flag
+ *   - `accountFeatures`: account-level entitlements (e.g. purchased add-on
+ *     bundles). A NAMED field so it can never be silently dropped by a caller
+ *     that omits a trailing positional arg.
  * @returns Sorted array of enabled feature flags
  */
-export function resolveUserFeatures(tier, featureOverrides, isSuperAdmin, accountFeatures) {
+export function resolveUserFeatures(tier, opts) {
+    const { overrides: featureOverrides, isSuperAdmin, accountFeatures } = opts ?? {};
     // Sysadmins get everything regardless of tier.
     if (isSuperAdmin)
         return [...ALL_FEATURE_FLAGS];
@@ -108,6 +113,6 @@ export function resolveUserFeatures(tier, featureOverrides, isSuperAdmin, accoun
  * @returns true if the feature is enabled
  */
 export function hasFeature(tier, feature, featureOverrides, isSuperAdmin, accountFeatures) {
-    return resolveUserFeatures(tier, featureOverrides, isSuperAdmin, accountFeatures).includes(feature);
+    return resolveUserFeatures(tier, { overrides: featureOverrides, isSuperAdmin, accountFeatures }).includes(feature);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"feature-flags.js","sourceRoot":"","sources":["../../src/types/feature-flags.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { QuotaTier } from './quota-tiers.js';\n\n// Feature flag identifiers\n\n/** Canonical feature flag identifiers. */\nexport type FeatureFlag =\n  | 'priority_support'\n  | 'custom_integrations'\n  | 'ai_generation'\n  | 'bulk_operations'\n  | 'audit_log'\n  | 'sso';\n\n/** All valid feature flags (order determines display order). */\nexport const ALL_FEATURE_FLAGS: readonly FeatureFlag[] = [\n  'priority_support',\n  'ai_generation',\n  'bulk_operations',\n  'custom_integrations',\n  'audit_log',\n  'sso',\n];\n\n/** Check whether a string is a valid FeatureFlag. */\nexport function isValidFeatureFlag(value: string): value is FeatureFlag {\n  return (ALL_FEATURE_FLAGS as readonly string[]).includes(value);\n}\n\n// Tier-to-feature mapping\n\n/** Features enabled by default for each tier. */\nexport const TIER_FEATURES: Record<QuotaTier, readonly FeatureFlag[]> = {\n  developer: [],\n  pro: ['priority_support', 'ai_generation', 'bulk_operations'],\n  // Team adds audit_log (collaboration/governance); Enterprise unlocks all,\n  // including custom_integrations.\n  team: ['priority_support', 'ai_generation', 'bulk_operations', 'audit_log'],\n  enterprise: [...ALL_FEATURE_FLAGS],\n};\n\n// Feature metadata (for display)\n\n/** Human-readable metadata for each feature flag. */\nexport const FEATURE_METADATA: Record<FeatureFlag, { label: string; description: string }> = {\n  priority_support: {\n    label: 'Priority Support',\n    description: 'Faster response times and dedicated support channels',\n  },\n  ai_generation: {\n    label: 'AI Generation',\n    description: 'AI-powered pipeline and plugin generation',\n  },\n  bulk_operations: {\n    label: 'Bulk Operations',\n    description: 'Batch create, update, and delete for pipelines and plugins',\n  },\n  custom_integrations: {\n    label: 'Custom Integrations',\n    description: 'Connect to external services and custom webhook endpoints',\n  },\n  audit_log: {\n    label: 'Audit Log',\n    description: 'Detailed audit trail of all user and system actions',\n  },\n  sso: {\n    label: 'SSO / IdP',\n    description: 'Single sign-on and external identity-provider configurations',\n  },\n};\n\n// Resolution logic\n\n/**\n * Resolve a user's effective feature set.\n *\n * 1. Sysadmins (isSuperAdmin) always get ALL features.\n * 2. Start with the tier's default features.\n * 3. Apply per-user overrides: `true` adds a feature, `false` removes it.\n * 4. Invalid override keys are silently ignored.\n *\n * @param tier - The organization's quota tier\n * @param featureOverrides - Per-user overrides (key = feature flag, value = enabled)\n * @param isSuperAdmin - Whether the user has the global super-admin flag\n * @returns Sorted array of enabled feature flags\n */\nexport function resolveUserFeatures(\n  tier: QuotaTier,\n  featureOverrides?: Record<string, boolean> | null,\n  isSuperAdmin?: boolean,\n  accountFeatures?: readonly string[] | null,\n): FeatureFlag[] {\n  // Sysadmins get everything regardless of tier.\n  if (isSuperAdmin) return [...ALL_FEATURE_FLAGS];\n\n  // Start with tier defaults\n  const features = new Set<FeatureFlag>(TIER_FEATURES[tier] ?? []);\n\n  // Account-level entitlements (purchased feature bundles — audit_log/sso).\n  // Applied before per-user overrides so an explicit user override still wins.\n  if (accountFeatures) {\n    for (const key of accountFeatures) {\n      if (isValidFeatureFlag(key)) features.add(key);\n    }\n  }\n\n  // Apply per-user overrides\n  if (featureOverrides) {\n    for (const [key, enabled] of Object.entries(featureOverrides)) {\n      if (!isValidFeatureFlag(key)) continue;\n      if (enabled) {\n        features.add(key);\n      } else {\n        features.delete(key);\n      }\n    }\n  }\n\n  // Return in canonical order\n  return ALL_FEATURE_FLAGS.filter(f => features.has(f));\n}\n\n/**\n * Check if a specific feature is enabled for a user. Delegates to\n * {@link resolveUserFeatures} so it stays in lockstep — including account-level\n * entitlements purchased via add-on bundles (`accountFeatures`).\n *\n * @param tier - The organization's quota tier\n * @param feature - The feature flag to check\n * @param featureOverrides - Per-user overrides\n * @param isSuperAdmin - Whether the user has the global super-admin flag\n * @param accountFeatures - Account-level entitlements (e.g. bundle-granted)\n * @returns true if the feature is enabled\n */\nexport function hasFeature(\n  tier: QuotaTier,\n  feature: FeatureFlag,\n  featureOverrides?: Record<string, boolean> | null,\n  isSuperAdmin?: boolean,\n  accountFeatures?: readonly string[] | null,\n): boolean {\n  return resolveUserFeatures(tier, featureOverrides, isSuperAdmin, accountFeatures).includes(feature);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"feature-flags.js","sourceRoot":"","sources":["../../src/types/feature-flags.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAetC,gEAAgE;AAChE,MAAM,CAAC,MAAM,iBAAiB,GAA2B;IACvD,kBAAkB;IAClB,eAAe;IACf,iBAAiB;IACjB,qBAAqB;IACrB,WAAW;IACX,KAAK;CACN,CAAC;AAEF,qDAAqD;AACrD,MAAM,UAAU,kBAAkB,CAAC,KAAa;IAC9C,OAAQ,iBAAuC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAClE,CAAC;AAED,0BAA0B;AAE1B,iDAAiD;AACjD,MAAM,CAAC,MAAM,aAAa,GAA8C;IACtE,SAAS,EAAE,EAAE;IACb,GAAG,EAAE,CAAC,kBAAkB,EAAE,eAAe,EAAE,iBAAiB,CAAC;IAC7D,8EAA8E;IAC9E,8EAA8E;IAC9E,IAAI,EAAE,CAAC,kBAAkB,EAAE,eAAe,EAAE,iBAAiB,EAAE,WAAW,EAAE,KAAK,CAAC;IAClF,UAAU,EAAE,CAAC,GAAG,iBAAiB,CAAC;CACnC,CAAC;AAEF,iCAAiC;AAEjC,qDAAqD;AACrD,MAAM,CAAC,MAAM,gBAAgB,GAAgE;IAC3F,gBAAgB,EAAE;QAChB,KAAK,EAAE,kBAAkB;QACzB,WAAW,EAAE,sDAAsD;KACpE;IACD,aAAa,EAAE;QACb,KAAK,EAAE,eAAe;QACtB,WAAW,EAAE,2CAA2C;KACzD;IACD,eAAe,EAAE;QACf,KAAK,EAAE,iBAAiB;QACxB,WAAW,EAAE,4DAA4D;KAC1E;IACD,mBAAmB,EAAE;QACnB,KAAK,EAAE,qBAAqB;QAC5B,WAAW,EAAE,2DAA2D;KACzE;IACD,SAAS,EAAE;QACT,KAAK,EAAE,WAAW;QAClB,WAAW,EAAE,qDAAqD;KACnE;IACD,GAAG,EAAE;QACH,KAAK,EAAE,WAAW;QAClB,WAAW,EAAE,8DAA8D;KAC5E;CACF,CAAC;AAEF,mBAAmB;AAEnB;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,mBAAmB,CACjC,IAAe,EACf,IAIC;IAED,MAAM,EAAE,SAAS,EAAE,gBAAgB,EAAE,YAAY,EAAE,eAAe,EAAE,GAAG,IAAI,IAAI,EAAE,CAAC;IAElF,+CAA+C;IAC/C,IAAI,YAAY;QAAE,OAAO,CAAC,GAAG,iBAAiB,CAAC,CAAC;IAEhD,2BAA2B;IAC3B,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAc,aAAa,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;IAEjE,0EAA0E;IAC1E,6EAA6E;IAC7E,IAAI,eAAe,EAAE,CAAC;QACpB,KAAK,MAAM,GAAG,IAAI,eAAe,EAAE,CAAC;YAClC,IAAI,kBAAkB,CAAC,GAAG,CAAC;gBAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACjD,CAAC;IACH,CAAC;IAED,2BAA2B;IAC3B,IAAI,gBAAgB,EAAE,CAAC;QACrB,KAAK,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAE,CAAC;YAC9D,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC;gBAAE,SAAS;YACvC,IAAI,OAAO,EAAE,CAAC;gBACZ,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACpB,CAAC;iBAAM,CAAC;gBACN,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACvB,CAAC;QACH,CAAC;IACH,CAAC;IAED,4BAA4B;IAC5B,OAAO,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,UAAU,CACxB,IAAe,EACf,OAAoB,EACpB,gBAAiD,EACjD,YAAsB,EACtB,eAA0C;IAE1C,OAAO,mBAAmB,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE,gBAAgB,EAAE,YAAY,EAAE,eAAe,EAAE,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;AACrH,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { QuotaTier } from './quota-tiers.js';\n\n// Feature flag identifiers\n\n/** Canonical feature flag identifiers. */\nexport type FeatureFlag =\n  | 'priority_support'\n  | 'custom_integrations'\n  | 'ai_generation'\n  | 'bulk_operations'\n  | 'audit_log'\n  | 'sso';\n\n/** All valid feature flags (order determines display order). */\nexport const ALL_FEATURE_FLAGS: readonly FeatureFlag[] = [\n  'priority_support',\n  'ai_generation',\n  'bulk_operations',\n  'custom_integrations',\n  'audit_log',\n  'sso',\n];\n\n/** Check whether a string is a valid FeatureFlag. */\nexport function isValidFeatureFlag(value: string): value is FeatureFlag {\n  return (ALL_FEATURE_FLAGS as readonly string[]).includes(value);\n}\n\n// Tier-to-feature mapping\n\n/** Features enabled by default for each tier. */\nexport const TIER_FEATURES: Record<QuotaTier, readonly FeatureFlag[]> = {\n  developer: [],\n  pro: ['priority_support', 'ai_generation', 'bulk_operations'],\n  // Team adds audit_log (collaboration/governance) and sso (SSO/IdP is INCLUDED\n  // in Team, not an add-on); Enterprise unlocks all, incl. custom_integrations.\n  team: ['priority_support', 'ai_generation', 'bulk_operations', 'audit_log', 'sso'],\n  enterprise: [...ALL_FEATURE_FLAGS],\n};\n\n// Feature metadata (for display)\n\n/** Human-readable metadata for each feature flag. */\nexport const FEATURE_METADATA: Record<FeatureFlag, { label: string; description: string }> = {\n  priority_support: {\n    label: 'Priority Support',\n    description: 'Faster response times and dedicated support channels',\n  },\n  ai_generation: {\n    label: 'AI Generation',\n    description: 'AI-powered pipeline and plugin generation',\n  },\n  bulk_operations: {\n    label: 'Bulk Operations',\n    description: 'Batch create, update, and delete for pipelines and plugins',\n  },\n  custom_integrations: {\n    label: 'Custom Integrations',\n    description: 'Connect to external services and custom webhook endpoints',\n  },\n  audit_log: {\n    label: 'Audit Log',\n    description: 'Detailed audit trail of all user and system actions',\n  },\n  sso: {\n    label: 'SSO / IdP',\n    description: 'Single sign-on and external identity-provider configurations',\n  },\n};\n\n// Resolution logic\n\n/**\n * Resolve a user's effective feature set.\n *\n * 1. Sysadmins (isSuperAdmin) always get ALL features.\n * 2. Start with the tier's default features.\n * 3. Apply per-user overrides: `true` adds a feature, `false` removes it.\n * 4. Invalid override keys are silently ignored.\n *\n * @param tier - The organization's quota tier\n * @param opts - Resolution options:\n *   - `overrides`: per-user overrides (key = feature flag, value = enabled)\n *   - `isSuperAdmin`: whether the user has the global super-admin flag\n *   - `accountFeatures`: account-level entitlements (e.g. purchased add-on\n *     bundles). A NAMED field so it can never be silently dropped by a caller\n *     that omits a trailing positional arg.\n * @returns Sorted array of enabled feature flags\n */\nexport function resolveUserFeatures(\n  tier: QuotaTier,\n  opts?: {\n    overrides?: Record<string, boolean> | null;\n    isSuperAdmin?: boolean;\n    accountFeatures?: readonly string[] | null;\n  },\n): FeatureFlag[] {\n  const { overrides: featureOverrides, isSuperAdmin, accountFeatures } = opts ?? {};\n\n  // Sysadmins get everything regardless of tier.\n  if (isSuperAdmin) return [...ALL_FEATURE_FLAGS];\n\n  // Start with tier defaults\n  const features = new Set<FeatureFlag>(TIER_FEATURES[tier] ?? []);\n\n  // Account-level entitlements (purchased feature bundles — audit_log/sso).\n  // Applied before per-user overrides so an explicit user override still wins.\n  if (accountFeatures) {\n    for (const key of accountFeatures) {\n      if (isValidFeatureFlag(key)) features.add(key);\n    }\n  }\n\n  // Apply per-user overrides\n  if (featureOverrides) {\n    for (const [key, enabled] of Object.entries(featureOverrides)) {\n      if (!isValidFeatureFlag(key)) continue;\n      if (enabled) {\n        features.add(key);\n      } else {\n        features.delete(key);\n      }\n    }\n  }\n\n  // Return in canonical order\n  return ALL_FEATURE_FLAGS.filter(f => features.has(f));\n}\n\n/**\n * Check if a specific feature is enabled for a user. Delegates to\n * {@link resolveUserFeatures} so it stays in lockstep — including account-level\n * entitlements purchased via add-on bundles (`accountFeatures`).\n *\n * @param tier - The organization's quota tier\n * @param feature - The feature flag to check\n * @param featureOverrides - Per-user overrides\n * @param isSuperAdmin - Whether the user has the global super-admin flag\n * @param accountFeatures - Account-level entitlements (e.g. bundle-granted)\n * @returns true if the feature is enabled\n */\nexport function hasFeature(\n  tier: QuotaTier,\n  feature: FeatureFlag,\n  featureOverrides?: Record<string, boolean> | null,\n  isSuperAdmin?: boolean,\n  accountFeatures?: readonly string[] | null,\n): boolean {\n  return resolveUserFeatures(tier, { overrides: featureOverrides, isSuperAdmin, accountFeatures }).includes(feature);\n}\n"]}

package/lib/types/permissions.d.ts

@@ -17,6 +17,23 @@ export type Permission = 'pipelines:read' | 'pipelines:write' | 'plugins:read' |
 export declare const ALL_PERMISSIONS: readonly Permission[];
 /** Check whether a string is a valid Permission. */
 export declare function isValidPermission(value: string): value is Permission;
+/**
+ * Permissions that must NEVER be grantable through a user-authored CUSTOM Role —
+ * they gate platform-operator surfaces (the shared image registry), so allowing
+ * an org admin to mint a Role carrying them would be a latent privilege
+ * escalation the moment those permissions get wired to an endpoint. Built-in
+ * Role seeds (e.g. `member` carrying `registry:read`) are system-created and are
+ * NOT subject to this list; it constrains only custom-Role authoring.
+ */
+export declare const SUPERADMIN_ONLY_PERMISSIONS: readonly Permission[];
+/**
+ * Permissions an org may assign via a CUSTOM Role — every permission except the
+ * {@link SUPERADMIN_ONLY_PERMISSIONS}. Custom-Role create/update validates the
+ * requested permission set against this (see platform roles-service).
+ */
+export declare const ORG_ASSIGNABLE_PERMISSIONS: readonly Permission[];
+/** Whether `permission` may be granted through a user-authored custom Role. */
+export declare function isOrgAssignablePermission(permission: Permission): boolean;
 /**
  * Seed bundle for each built-in Role, keyed by the coarse role it grants.
  * Consumed by the Role seeder + the startup backfill to populate a built-in

package/lib/types/permissions.js

@@ -19,6 +19,28 @@ export const ALL_PERMISSIONS = [
 export function isValidPermission(value) {
     return ALL_PERMISSIONS.includes(value);
 }
+/**
+ * Permissions that must NEVER be grantable through a user-authored CUSTOM Role —
+ * they gate platform-operator surfaces (the shared image registry), so allowing
+ * an org admin to mint a Role carrying them would be a latent privilege
+ * escalation the moment those permissions get wired to an endpoint. Built-in
+ * Role seeds (e.g. `member` carrying `registry:read`) are system-created and are
+ * NOT subject to this list; it constrains only custom-Role authoring.
+ */
+export const SUPERADMIN_ONLY_PERMISSIONS = [
+    'registry:read',
+    'registry:write',
+];
+/**
+ * Permissions an org may assign via a CUSTOM Role — every permission except the
+ * {@link SUPERADMIN_ONLY_PERMISSIONS}. Custom-Role create/update validates the
+ * requested permission set against this (see platform roles-service).
+ */
+export const ORG_ASSIGNABLE_PERMISSIONS = ALL_PERMISSIONS.filter((p) => !SUPERADMIN_ONLY_PERMISSIONS.includes(p));
+/** Whether `permission` may be granted through a user-authored custom Role. */
+export function isOrgAssignablePermission(permission) {
+    return !SUPERADMIN_ONLY_PERMISSIONS.includes(permission);
+}
 // =============================================================================
 // Built-in Role seed bundles
 // =============================================================================
@@ -100,4 +122,4 @@ export function hasPermission(granted, permission, isSuperAdmin) {
         return true;
     return !!granted && granted.includes(permission);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permissions.js","sourceRoot":"","sources":["../../src/types/permissions.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAuDtC,4EAA4E;AAC5E,MAAM,CAAC,MAAM,eAAe,GAA0B;IACpD,gBAAgB,EAAE,iBAAiB;IACnC,cAAc,EAAE,eAAe;IAC/B,iBAAiB,EAAE,kBAAkB;IACrC,gBAAgB,EAAE,cAAc,EAAE,oBAAoB;IACtD,iBAAiB,EAAE,kBAAkB;IACrC,oBAAoB,EAAE,qBAAqB;IAC3C,cAAc;IACd,eAAe,EAAE,gBAAgB;IACjC,cAAc,EAAE,gBAAgB;IAChC,aAAa;IACb,eAAe,EAAE,gBAAgB;IACjC,cAAc;CACf,CAAC;AAEF,oDAAoD;AACpD,MAAM,UAAU,iBAAiB,CAAC,KAAa;IAC7C,OAAQ,eAAqC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAChE,CAAC;AAED,gFAAgF;AAChF,6BAA6B;AAC7B,gFAAgF;AAEhF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,kBAAkB,GAA0B;IAChD,gBAAgB,EAAE,iBAAiB;IACnC,cAAc,EAAE,eAAe;IAC/B,iBAAiB;IACjB,iBAAiB;IACjB,oBAAoB;IACpB,cAAc;IACd,eAAe,EAAE,gBAAgB;IACjC,cAAc;IACd,aAAa;IACb,eAAe;CAChB,CAAC;AAEF,MAAM,iBAAiB,GAA0B,CAAC,GAAG,eAAe,CAAC,CAAC;AAEtE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAA2C;IACtE,MAAM,EAAE,kBAAkB;IAC1B,KAAK,EAAE,iBAAiB;IACxB,KAAK,EAAE,iBAAiB;CACzB,CAAC;AAEF,gFAAgF;AAChF,aAAa;AACb,gFAAgF;AAEhF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,sBAAsB,CACpC,mBAA8C,EAC9C,YAAsB;IAEtB,IAAI,YAAY;QAAE,OAAO,CAAC,GAAG,eAAe,CAAC,CAAC;IAE9C,MAAM,KAAK,GAAG,IAAI,GAAG,EAAc,CAAC;IACpC,IAAI,mBAAmB,EAAE,CAAC;QACxB,KAAK,MAAM,CAAC,IAAI,mBAAmB,EAAE,CAAC;YACpC,IAAI,iBAAiB,CAAC,CAAC,CAAC;gBAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACzC,CAAC;IACH,CAAC;IACD,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACnD,CAAC;AAED,oFAAoF;AACpF,MAAM,UAAU,aAAa,CAC3B,OAA6C,EAC7C,UAAsB,EACtB,YAAsB;IAEtB,IAAI,YAAY;QAAE,OAAO,IAAI,CAAC;IAC9B,OAAO,CAAC,CAAC,OAAO,IAAI,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;AACnD,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { OrgRole } from './common.js';\n\n// =============================================================================\n// Permission identifiers\n// =============================================================================\n\n/**\n * Canonical fine-grained permission identifiers, in `resource:action` form.\n *\n * These are the ORG-SCOPED capabilities a Role can grant (RBAC). Coarse by\n * design — `:write` covers create/update/delete for a resource — so the catalog\n * and permission-picker UI stay small; split a `:write` into `:create`/`:delete`\n * later if a resource needs it.\n *\n * NOT modeled here (intentionally): platform-operator actions (org delete, tier/\n * quota override, user admin, impersonation, platform settings) stay behind the\n * global `isSuperAdmin` flag, not a per-org permission; and `requireStepUp`\n * (MFA) / `requireFeature` (plan entitlements) remain orthogonal gates.\n */\nexport type Permission =\n  // Pipelines\n  | 'pipelines:read'\n  | 'pipelines:write'\n  // Plugins\n  | 'plugins:read'\n  | 'plugins:write'\n  // Compliance\n  | 'compliance:read'\n  | 'compliance:write'\n  // Members & access\n  | 'members:manage'\n  | 'roles:manage'\n  | 'invitations:manage'\n  // Observability\n  | 'dashboards:read'\n  | 'dashboards:write'\n  | 'observability:read'\n  | 'observability:write'\n  // Insights\n  | 'reports:read'\n  // Messaging\n  | 'messages:read'\n  | 'messages:write'\n  // Billing & quotas\n  | 'billing:read'\n  | 'billing:manage'\n  | 'quotas:read'\n  // Registry\n  | 'registry:read'\n  | 'registry:write'\n  // Organization settings (IdP, KMS, AI config, general settings)\n  | 'org:settings';\n\n/** All valid permissions (order determines display order in the picker). */\nexport const ALL_PERMISSIONS: readonly Permission[] = [\n  'pipelines:read', 'pipelines:write',\n  'plugins:read', 'plugins:write',\n  'compliance:read', 'compliance:write',\n  'members:manage', 'roles:manage', 'invitations:manage',\n  'dashboards:read', 'dashboards:write',\n  'observability:read', 'observability:write',\n  'reports:read',\n  'messages:read', 'messages:write',\n  'billing:read', 'billing:manage',\n  'quotas:read',\n  'registry:read', 'registry:write',\n  'org:settings',\n];\n\n/** Check whether a string is a valid Permission. */\nexport function isValidPermission(value: string): value is Permission {\n  return (ALL_PERMISSIONS as readonly string[]).includes(value);\n}\n\n// =============================================================================\n// Built-in Role seed bundles\n// =============================================================================\n\n/**\n * Permission bundles used to SEED the built-in Roles (\"Admin\", \"Member\").\n *\n * This is the single definition of what those built-in Roles grant — it is used\n * when a Role record is created (and by the startup backfill) to populate that\n * Role's own `permissions[]`. It is NOT a runtime permission source: a user's\n * effective permissions come ONLY from the Roles assigned to them (see\n * {@link resolveUserPermissions}). The coarse `role` label (owner/admin/member)\n * survives only for `isAdmin`/ownership/display, never to grant permissions.\n *\n * - `member`  — day-to-day builder: read + write on pipelines/plugins, read\n *   elsewhere. No member/role/billing management, no compliance/alert authoring.\n * - `admin`   — full org administration (everything below).\n * - `owner`   — same as admin (ownership itself — transfer/delete — is gated\n *   separately, not via a permission).\n */\nconst MEMBER_PERMISSIONS: readonly Permission[] = [\n  'pipelines:read', 'pipelines:write',\n  'plugins:read', 'plugins:write',\n  'compliance:read',\n  'dashboards:read',\n  'observability:read',\n  'reports:read',\n  'messages:read', 'messages:write',\n  'billing:read',\n  'quotas:read',\n  'registry:read',\n];\n\nconst ADMIN_PERMISSIONS: readonly Permission[] = [...ALL_PERMISSIONS];\n\n/**\n * Seed bundle for each built-in Role, keyed by the coarse role it grants.\n * Consumed by the Role seeder + the startup backfill to populate a built-in\n * Role's `permissions[]`. NOT consulted at request time — see\n * {@link resolveUserPermissions}.\n */\nexport const ROLE_PERMISSIONS: Record<OrgRole, readonly Permission[]> = {\n  member: MEMBER_PERMISSIONS,\n  admin: ADMIN_PERMISSIONS,\n  owner: ADMIN_PERMISSIONS,\n};\n\n// =============================================================================\n// Resolution\n// =============================================================================\n\n/**\n * Resolve a user's effective org permissions from the Roles assigned to them.\n *\n * Single-source model: a user's abilities are EXACTLY the union of the\n * permissions carried by the Roles they hold (a Role = a named permission set;\n * built-in Roles carry their bundle explicitly, seeded from\n * {@link ROLE_PERMISSIONS}). There is no separate role-derived baseline — the\n * coarse `role` label no longer grants anything on its own.\n *\n * 1. Platform superadmins (`isSuperAdmin`) always get ALL permissions.\n * 2. Otherwise, union every permission granted by the user's assigned Roles.\n * 3. Invalid/unknown permission strings are silently ignored.\n *\n * @param assignedPermissions - Flattened permissions from every Role the user holds\n * @param isSuperAdmin - Whether the user has the global super-admin flag\n * @returns Effective permissions in canonical order\n */\nexport function resolveUserPermissions(\n  assignedPermissions?: readonly string[] | null,\n  isSuperAdmin?: boolean,\n): Permission[] {\n  if (isSuperAdmin) return [...ALL_PERMISSIONS];\n\n  const perms = new Set<Permission>();\n  if (assignedPermissions) {\n    for (const p of assignedPermissions) {\n      if (isValidPermission(p)) perms.add(p);\n    }\n  }\n  return ALL_PERMISSIONS.filter(p => perms.has(p));\n}\n\n/** Whether a resolved permission list grants `permission` (superadmin ⇒ always). */\nexport function hasPermission(\n  granted: readonly string[] | null | undefined,\n  permission: Permission,\n  isSuperAdmin?: boolean,\n): boolean {\n  if (isSuperAdmin) return true;\n  return !!granted && granted.includes(permission);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permissions.js","sourceRoot":"","sources":["../../src/types/permissions.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAuDtC,4EAA4E;AAC5E,MAAM,CAAC,MAAM,eAAe,GAA0B;IACpD,gBAAgB,EAAE,iBAAiB;IACnC,cAAc,EAAE,eAAe;IAC/B,iBAAiB,EAAE,kBAAkB;IACrC,gBAAgB,EAAE,cAAc,EAAE,oBAAoB;IACtD,iBAAiB,EAAE,kBAAkB;IACrC,oBAAoB,EAAE,qBAAqB;IAC3C,cAAc;IACd,eAAe,EAAE,gBAAgB;IACjC,cAAc,EAAE,gBAAgB;IAChC,aAAa;IACb,eAAe,EAAE,gBAAgB;IACjC,cAAc;CACf,CAAC;AAEF,oDAAoD;AACpD,MAAM,UAAU,iBAAiB,CAAC,KAAa;IAC7C,OAAQ,eAAqC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAA0B;IAChE,eAAe;IACf,gBAAgB;CACjB,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,0BAA0B,GACrC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,2BAA2B,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;AAE1E,+EAA+E;AAC/E,MAAM,UAAU,yBAAyB,CAAC,UAAsB;IAC9D,OAAO,CAAC,2BAA2B,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;AAC3D,CAAC;AAED,gFAAgF;AAChF,6BAA6B;AAC7B,gFAAgF;AAEhF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,kBAAkB,GAA0B;IAChD,gBAAgB,EAAE,iBAAiB;IACnC,cAAc,EAAE,eAAe;IAC/B,iBAAiB;IACjB,iBAAiB;IACjB,oBAAoB;IACpB,cAAc;IACd,eAAe,EAAE,gBAAgB;IACjC,cAAc;IACd,aAAa;IACb,eAAe;CAChB,CAAC;AAEF,MAAM,iBAAiB,GAA0B,CAAC,GAAG,eAAe,CAAC,CAAC;AAEtE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAA2C;IACtE,MAAM,EAAE,kBAAkB;IAC1B,KAAK,EAAE,iBAAiB;IACxB,KAAK,EAAE,iBAAiB;CACzB,CAAC;AAEF,gFAAgF;AAChF,aAAa;AACb,gFAAgF;AAEhF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,sBAAsB,CACpC,mBAA8C,EAC9C,YAAsB;IAEtB,IAAI,YAAY;QAAE,OAAO,CAAC,GAAG,eAAe,CAAC,CAAC;IAE9C,MAAM,KAAK,GAAG,IAAI,GAAG,EAAc,CAAC;IACpC,IAAI,mBAAmB,EAAE,CAAC;QACxB,KAAK,MAAM,CAAC,IAAI,mBAAmB,EAAE,CAAC;YACpC,IAAI,iBAAiB,CAAC,CAAC,CAAC;gBAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACzC,CAAC;IACH,CAAC;IACD,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACnD,CAAC;AAED,oFAAoF;AACpF,MAAM,UAAU,aAAa,CAC3B,OAA6C,EAC7C,UAAsB,EACtB,YAAsB;IAEtB,IAAI,YAAY;QAAE,OAAO,IAAI,CAAC;IAC9B,OAAO,CAAC,CAAC,OAAO,IAAI,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;AACnD,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { OrgRole } from './common.js';\n\n// =============================================================================\n// Permission identifiers\n// =============================================================================\n\n/**\n * Canonical fine-grained permission identifiers, in `resource:action` form.\n *\n * These are the ORG-SCOPED capabilities a Role can grant (RBAC). Coarse by\n * design — `:write` covers create/update/delete for a resource — so the catalog\n * and permission-picker UI stay small; split a `:write` into `:create`/`:delete`\n * later if a resource needs it.\n *\n * NOT modeled here (intentionally): platform-operator actions (org delete, tier/\n * quota override, user admin, impersonation, platform settings) stay behind the\n * global `isSuperAdmin` flag, not a per-org permission; and `requireStepUp`\n * (MFA) / `requireFeature` (plan entitlements) remain orthogonal gates.\n */\nexport type Permission =\n  // Pipelines\n  | 'pipelines:read'\n  | 'pipelines:write'\n  // Plugins\n  | 'plugins:read'\n  | 'plugins:write'\n  // Compliance\n  | 'compliance:read'\n  | 'compliance:write'\n  // Members & access\n  | 'members:manage'\n  | 'roles:manage'\n  | 'invitations:manage'\n  // Observability\n  | 'dashboards:read'\n  | 'dashboards:write'\n  | 'observability:read'\n  | 'observability:write'\n  // Insights\n  | 'reports:read'\n  // Messaging\n  | 'messages:read'\n  | 'messages:write'\n  // Billing & quotas\n  | 'billing:read'\n  | 'billing:manage'\n  | 'quotas:read'\n  // Registry\n  | 'registry:read'\n  | 'registry:write'\n  // Organization settings (IdP, KMS, AI config, general settings)\n  | 'org:settings';\n\n/** All valid permissions (order determines display order in the picker). */\nexport const ALL_PERMISSIONS: readonly Permission[] = [\n  'pipelines:read', 'pipelines:write',\n  'plugins:read', 'plugins:write',\n  'compliance:read', 'compliance:write',\n  'members:manage', 'roles:manage', 'invitations:manage',\n  'dashboards:read', 'dashboards:write',\n  'observability:read', 'observability:write',\n  'reports:read',\n  'messages:read', 'messages:write',\n  'billing:read', 'billing:manage',\n  'quotas:read',\n  'registry:read', 'registry:write',\n  'org:settings',\n];\n\n/** Check whether a string is a valid Permission. */\nexport function isValidPermission(value: string): value is Permission {\n  return (ALL_PERMISSIONS as readonly string[]).includes(value);\n}\n\n/**\n * Permissions that must NEVER be grantable through a user-authored CUSTOM Role —\n * they gate platform-operator surfaces (the shared image registry), so allowing\n * an org admin to mint a Role carrying them would be a latent privilege\n * escalation the moment those permissions get wired to an endpoint. Built-in\n * Role seeds (e.g. `member` carrying `registry:read`) are system-created and are\n * NOT subject to this list; it constrains only custom-Role authoring.\n */\nexport const SUPERADMIN_ONLY_PERMISSIONS: readonly Permission[] = [\n  'registry:read',\n  'registry:write',\n];\n\n/**\n * Permissions an org may assign via a CUSTOM Role — every permission except the\n * {@link SUPERADMIN_ONLY_PERMISSIONS}. Custom-Role create/update validates the\n * requested permission set against this (see platform roles-service).\n */\nexport const ORG_ASSIGNABLE_PERMISSIONS: readonly Permission[] =\n  ALL_PERMISSIONS.filter((p) => !SUPERADMIN_ONLY_PERMISSIONS.includes(p));\n\n/** Whether `permission` may be granted through a user-authored custom Role. */\nexport function isOrgAssignablePermission(permission: Permission): boolean {\n  return !SUPERADMIN_ONLY_PERMISSIONS.includes(permission);\n}\n\n// =============================================================================\n// Built-in Role seed bundles\n// =============================================================================\n\n/**\n * Permission bundles used to SEED the built-in Roles (\"Admin\", \"Member\").\n *\n * This is the single definition of what those built-in Roles grant — it is used\n * when a Role record is created (and by the startup backfill) to populate that\n * Role's own `permissions[]`. It is NOT a runtime permission source: a user's\n * effective permissions come ONLY from the Roles assigned to them (see\n * {@link resolveUserPermissions}). The coarse `role` label (owner/admin/member)\n * survives only for `isAdmin`/ownership/display, never to grant permissions.\n *\n * - `member`  — day-to-day builder: read + write on pipelines/plugins, read\n *   elsewhere. No member/role/billing management, no compliance/alert authoring.\n * - `admin`   — full org administration (everything below).\n * - `owner`   — same as admin (ownership itself — transfer/delete — is gated\n *   separately, not via a permission).\n */\nconst MEMBER_PERMISSIONS: readonly Permission[] = [\n  'pipelines:read', 'pipelines:write',\n  'plugins:read', 'plugins:write',\n  'compliance:read',\n  'dashboards:read',\n  'observability:read',\n  'reports:read',\n  'messages:read', 'messages:write',\n  'billing:read',\n  'quotas:read',\n  'registry:read',\n];\n\nconst ADMIN_PERMISSIONS: readonly Permission[] = [...ALL_PERMISSIONS];\n\n/**\n * Seed bundle for each built-in Role, keyed by the coarse role it grants.\n * Consumed by the Role seeder + the startup backfill to populate a built-in\n * Role's `permissions[]`. NOT consulted at request time — see\n * {@link resolveUserPermissions}.\n */\nexport const ROLE_PERMISSIONS: Record<OrgRole, readonly Permission[]> = {\n  member: MEMBER_PERMISSIONS,\n  admin: ADMIN_PERMISSIONS,\n  owner: ADMIN_PERMISSIONS,\n};\n\n// =============================================================================\n// Resolution\n// =============================================================================\n\n/**\n * Resolve a user's effective org permissions from the Roles assigned to them.\n *\n * Single-source model: a user's abilities are EXACTLY the union of the\n * permissions carried by the Roles they hold (a Role = a named permission set;\n * built-in Roles carry their bundle explicitly, seeded from\n * {@link ROLE_PERMISSIONS}). There is no separate role-derived baseline — the\n * coarse `role` label no longer grants anything on its own.\n *\n * 1. Platform superadmins (`isSuperAdmin`) always get ALL permissions.\n * 2. Otherwise, union every permission granted by the user's assigned Roles.\n * 3. Invalid/unknown permission strings are silently ignored.\n *\n * @param assignedPermissions - Flattened permissions from every Role the user holds\n * @param isSuperAdmin - Whether the user has the global super-admin flag\n * @returns Effective permissions in canonical order\n */\nexport function resolveUserPermissions(\n  assignedPermissions?: readonly string[] | null,\n  isSuperAdmin?: boolean,\n): Permission[] {\n  if (isSuperAdmin) return [...ALL_PERMISSIONS];\n\n  const perms = new Set<Permission>();\n  if (assignedPermissions) {\n    for (const p of assignedPermissions) {\n      if (isValidPermission(p)) perms.add(p);\n    }\n  }\n  return ALL_PERMISSIONS.filter(p => perms.has(p));\n}\n\n/** Whether a resolved permission list grants `permission` (superadmin ⇒ always). */\nexport function hasPermission(\n  granted: readonly string[] | null | undefined,\n  permission: Permission,\n  isSuperAdmin?: boolean,\n): boolean {\n  if (isSuperAdmin) return true;\n  return !!granted && granted.includes(permission);\n}\n"]}

package/package.json

@@ -85,7 +85,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "3.4.87",
+  "version": "3.4.89",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },