@pipeline-builder/api-core 3.4.96 → 3.4.97

package/lib/helpers/access-helpers.d.ts

@@ -1,4 +1,5 @@
 import type { Request, Response } from 'express';
+import type { Permission } from '../types/permissions.js';
 /**
  * Check whether a non-admin user may modify a public resource.
  *
@@ -18,4 +19,4 @@ import type { Request, Response } from 'express';
  */
 export declare function requirePublicAccess(req: Request, res: Response, resource: {
     accessModifier?: string;
-}): boolean;
+}, publishPermission?: Permission): boolean;

package/lib/helpers/access-helpers.js

@@ -1,6 +1,6 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-import { isSystemAdmin } from '../middleware/auth.js';
+import { isSystemAdmin, userHasPermission } from '../middleware/auth.js';
 import { ErrorCode } from '../types/error-codes.js';
 import { AccessModifier } from '../types/pipeline.js';
 import { sendError } from '../utils/response.js';
@@ -21,11 +21,17 @@ import { sendError } from '../utils/response.js';
  * await pipelineService.delete(id, orgId, userId);
  * ```
  */
-export function requirePublicAccess(req, res, resource) {
-    if (!isSystemAdmin(req) && resource.accessModifier !== AccessModifier.PRIVATE) {
-        sendError(res, 403, 'Only system admins can modify public resources.', ErrorCode.INSUFFICIENT_PERMISSIONS);
+export function requirePublicAccess(req, res, resource, publishPermission) {
+    // Private resources: no extra gate (org-scoping already applies). Public/non-private:
+    // a system admin OR the holder of the matching publish permission may modify it — so
+    // the same permission that let a non-superadmin PUBLISH it (create path) also lets
+    // them manage it. The write itself stays pinned to the caller's org, so this never
+    // grants cross-org reach. Without a publishPermission, it stays superadmin-only.
+    const mayModify = isSystemAdmin(req) || (!!publishPermission && userHasPermission(req, publishPermission));
+    if (!mayModify && resource.accessModifier !== AccessModifier.PRIVATE) {
+        sendError(res, 403, 'You lack permission to modify this public resource.', ErrorCode.INSUFFICIENT_PERMISSIONS);
         return false;
     }
     return true;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/helpers/org-hierarchy-http.d.ts

@@ -16,12 +16,22 @@ export interface OrgHierarchyHttpOptions {
     headers?: Record<string, string>;
     /** Per-request timeout override in ms (falls back to the client default). */
     timeout?: number;
+    /**
+     * When true, a non-2xx response THROWS instead of resolving to `undefined`.
+     * Default false (a 4xx/5xx maps to `undefined`, the fail-soft policy the
+     * message/reporting root-resolution callers rely on). A caller for whom a
+     * failed lookup must fail-CLOSED — e.g. a compliance scan, where treating a
+     * team org as parent-less would silently skip inherited blocking rules — sets
+     * this so it can distinguish "root org" (`undefined`) from "lookup failed".
+     */
+    throwOnHttpError?: boolean;
 }
 /**
  * Resolve an org's direct parent id via platform's
- * `GET /organization/:id/parent`. Returns `undefined` for a root org or a
- * non-2xx response. Throws on a transport failure (connection/timeout) so the
- * caller can apply its own fallback.
+ * `GET /organization/:id/parent`. Returns `undefined` for a root org. A non-2xx
+ * response resolves to `undefined` by default, or THROWS when
+ * `throwOnHttpError` is set. Always throws on a transport failure
+ * (connection/timeout) so the caller can apply its own fallback.
  */
 export declare function fetchParentOrgId(orgId: string, opts: OrgHierarchyHttpOptions): Promise<string | undefined>;
 /**

package/lib/helpers/org-hierarchy-http.js

@@ -34,15 +34,20 @@ function buildRequest(orgId, suffix, opts) {
 }
 /**
  * Resolve an org's direct parent id via platform's
- * `GET /organization/:id/parent`. Returns `undefined` for a root org or a
- * non-2xx response. Throws on a transport failure (connection/timeout) so the
- * caller can apply its own fallback.
+ * `GET /organization/:id/parent`. Returns `undefined` for a root org. A non-2xx
+ * response resolves to `undefined` by default, or THROWS when
+ * `throwOnHttpError` is set. Always throws on a transport failure
+ * (connection/timeout) so the caller can apply its own fallback.
  */
 export async function fetchParentOrgId(orgId, opts) {
     const { client, path, headers } = buildRequest(orgId, 'parent', opts);
     const res = await client.get(path, { headers, timeout: opts.timeout });
-    if (res.statusCode >= 400)
+    if (res.statusCode >= 400) {
+        if (opts.throwOnHttpError) {
+            throw new Error(`parent-org lookup failed for ${orgId}: HTTP ${res.statusCode}`);
+        }
         return undefined;
+    }
     return res.body?.data?.parentOrgId ?? undefined;
 }
 /**
@@ -69,4 +74,4 @@ export async function fetchOrgDescendants(orgId, opts) {
     // Only meaningful when the (validated) subtree is larger than the org itself.
     return orgIds.length > 1 ? orgIds : undefined;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"org-hierarchy-http.js","sourceRoot":"","sources":["../../src/helpers/org-hierarchy-http.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAsBhE,SAAS,YAAY,CACnB,KAAa,EACb,MAAgC,EAChC,IAA6B;IAE7B,MAAM,MAAM,GAAG,IAAI,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACpD,MAAM,IAAI,GAAG,iBAAiB,kBAAkB,CAAC,KAAK,CAAC,IAAI,MAAM,EAAE,CAAC;IACpE,MAAM,OAAO,GAA2B;QACtC,aAAa,EAAE,oBAAoB,CAAC;YAClC,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,KAAK,EAAE,IAAI,CAAC,SAAS,IAAI,KAAK;YAC9B,IAAI,EAAE,IAAI,CAAC,IAAI,IAAI,QAAQ;SAC5B,CAAC;QACF,GAAG,IAAI,CAAC,OAAO;KAChB,CAAC;IACF,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;AACnC,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,KAAa,EAAE,IAA6B;IACjF,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;IACtE,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,GAAG,CAA6C,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;IACnH,IAAI,GAAG,CAAC,UAAU,IAAI,GAAG;QAAE,OAAO,SAAS,CAAC;IAC5C,OAAO,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,IAAI,SAAS,CAAC;AAClD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,KAAa,EAAE,IAA6B;IACpF,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,YAAY,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,CAAC;IAC3E,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,GAAG,CAAkC,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;IACxG,IAAI,GAAG,CAAC,UAAU,IAAI,GAAG;QAAE,OAAO,SAAS,CAAC;IAC5C,MAAM,GAAG,GAAG,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC;IACnC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;QAAE,OAAO,SAAS,CAAC;IAC1C,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,EAAgB,EAAE,CAAC,OAAO,EAAE,KAAK,QAAQ,CAAC,CAAC;IACxE,8EAA8E;IAC9E,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;AAChD,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Org → team hierarchy lookups over HTTP against the platform service.\n *\n * The Mongoose-based traversal in {@link ./org-hierarchy} is for services that\n * own the org table (platform, quota). Everyone else reads the hierarchy over\n * the wire from platform's authoritative `/organization/:id/*` endpoints. This\n * module centralizes the transport for those reads — URL construction, the\n * signed service-token auth header, and timeout+retry via the shared\n * {@link InternalHttpClient} — so compliance, reporting, and any future caller\n * share ONE mechanism instead of each hand-rolling a `fetch`/client with its\n * own auth and failure semantics.\n *\n * These functions deliberately do NOT swallow transport errors: a connection\n * failure/timeout propagates so each caller keeps its own fallback policy (log\n * level, degrade-to-self vs. return-undefined). A non-2xx response is treated\n * as \"no data\" (returns undefined), matching what the callers previously did.\n */\n\nimport { getServiceAuthHeader } from '../middleware/auth.js';\nimport { InternalHttpClient } from '../services/http-client.js';\nimport type { ServiceConfig } from '../types/common.js';\n\n/** Options shared by the platform org-hierarchy HTTP lookups. */\nexport interface OrgHierarchyHttpOptions {\n  /** Platform service host/port (+ optional default timeout) for the client. */\n  service: ServiceConfig;\n  /** Service name minted into the service-auth JWT `sub` (e.g. 'compliance'). */\n  serviceName: string;\n  /**\n   * Org id embedded in the signed service token's org context. Defaults to the\n   * queried `orgId`; pass a system org id for a system-scoped lookup.\n   */\n  authOrgId?: string;\n  /** Role carried by the service token (default 'member' — least privilege). */\n  role?: 'owner' | 'admin' | 'member';\n  /** Extra request headers merged after `Authorization` (e.g. `x-org-id`). */\n  headers?: Record<string, string>;\n  /** Per-request timeout override in ms (falls back to the client default). */\n  timeout?: number;\n}\n\nfunction buildRequest(\n  orgId: string,\n  suffix: 'parent' | 'descendants',\n  opts: OrgHierarchyHttpOptions,\n): { client: InternalHttpClient; path: string; headers: Record<string, string> } {\n  const client = new InternalHttpClient(opts.service);\n  const path = `/organization/${encodeURIComponent(orgId)}/${suffix}`;\n  const headers: Record<string, string> = {\n    Authorization: getServiceAuthHeader({\n      serviceName: opts.serviceName,\n      orgId: opts.authOrgId ?? orgId,\n      role: opts.role ?? 'member',\n    }),\n    ...opts.headers,\n  };\n  return { client, path, headers };\n}\n\n/**\n * Resolve an org's direct parent id via platform's\n * `GET /organization/:id/parent`. Returns `undefined` for a root org or a\n * non-2xx response. Throws on a transport failure (connection/timeout) so the\n * caller can apply its own fallback.\n */\nexport async function fetchParentOrgId(orgId: string, opts: OrgHierarchyHttpOptions): Promise<string | undefined> {\n  const { client, path, headers } = buildRequest(orgId, 'parent', opts);\n  const res = await client.get<{ data?: { parentOrgId?: string | null } }>(path, { headers, timeout: opts.timeout });\n  if (res.statusCode >= 400) return undefined;\n  return res.body?.data?.parentOrgId ?? undefined;\n}\n\n/**\n * Resolve `[self, ...descendantOrgIds]` for an org via platform's\n * `GET /organization/:id/descendants`. Returns the id list only when it is\n * larger than the org itself (a real subtree), else `undefined`; also\n * `undefined` on a non-2xx response. Throws on a transport failure so the\n * caller can apply its own fallback.\n *\n * This is a trust boundary: the response is validated element-by-element rather\n * than cast — every entry must be a string, and any non-string is dropped — so\n * a malformed payload can never smuggle a non-string into the returned\n * `string[]`.\n */\nexport async function fetchOrgDescendants(orgId: string, opts: OrgHierarchyHttpOptions): Promise<string[] | undefined> {\n  const { client, path, headers } = buildRequest(orgId, 'descendants', opts);\n  const res = await client.get<{ data?: { orgIds?: unknown } }>(path, { headers, timeout: opts.timeout });\n  if (res.statusCode >= 400) return undefined;\n  const ids = res.body?.data?.orgIds;\n  if (!Array.isArray(ids)) return undefined;\n  const orgIds = ids.filter((id): id is string => typeof id === 'string');\n  // Only meaningful when the (validated) subtree is larger than the org itself.\n  return orgIds.length > 1 ? orgIds : undefined;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"org-hierarchy-http.js","sourceRoot":"","sources":["../../src/helpers/org-hierarchy-http.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AA+BhE,SAAS,YAAY,CACnB,KAAa,EACb,MAAgC,EAChC,IAA6B;IAE7B,MAAM,MAAM,GAAG,IAAI,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACpD,MAAM,IAAI,GAAG,iBAAiB,kBAAkB,CAAC,KAAK,CAAC,IAAI,MAAM,EAAE,CAAC;IACpE,MAAM,OAAO,GAA2B;QACtC,aAAa,EAAE,oBAAoB,CAAC;YAClC,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,KAAK,EAAE,IAAI,CAAC,SAAS,IAAI,KAAK;YAC9B,IAAI,EAAE,IAAI,CAAC,IAAI,IAAI,QAAQ;SAC5B,CAAC;QACF,GAAG,IAAI,CAAC,OAAO;KAChB,CAAC;IACF,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;AACnC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,KAAa,EAAE,IAA6B;IACjF,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;IACtE,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,GAAG,CAA6C,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;IACnH,IAAI,GAAG,CAAC,UAAU,IAAI,GAAG,EAAE,CAAC;QAC1B,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,gCAAgC,KAAK,UAAU,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC;QACnF,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,IAAI,SAAS,CAAC;AAClD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,KAAa,EAAE,IAA6B;IACpF,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,YAAY,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,CAAC;IAC3E,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,GAAG,CAAkC,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;IACxG,IAAI,GAAG,CAAC,UAAU,IAAI,GAAG;QAAE,OAAO,SAAS,CAAC;IAC5C,MAAM,GAAG,GAAG,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC;IACnC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;QAAE,OAAO,SAAS,CAAC;IAC1C,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,EAAgB,EAAE,CAAC,OAAO,EAAE,KAAK,QAAQ,CAAC,CAAC;IACxE,8EAA8E;IAC9E,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;AAChD,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Org → team hierarchy lookups over HTTP against the platform service.\n *\n * The Mongoose-based traversal in {@link ./org-hierarchy} is for services that\n * own the org table (platform, quota). Everyone else reads the hierarchy over\n * the wire from platform's authoritative `/organization/:id/*` endpoints. This\n * module centralizes the transport for those reads — URL construction, the\n * signed service-token auth header, and timeout+retry via the shared\n * {@link InternalHttpClient} — so compliance, reporting, and any future caller\n * share ONE mechanism instead of each hand-rolling a `fetch`/client with its\n * own auth and failure semantics.\n *\n * These functions deliberately do NOT swallow transport errors: a connection\n * failure/timeout propagates so each caller keeps its own fallback policy (log\n * level, degrade-to-self vs. return-undefined). A non-2xx response is treated\n * as \"no data\" (returns undefined), matching what the callers previously did.\n */\n\nimport { getServiceAuthHeader } from '../middleware/auth.js';\nimport { InternalHttpClient } from '../services/http-client.js';\nimport type { ServiceConfig } from '../types/common.js';\n\n/** Options shared by the platform org-hierarchy HTTP lookups. */\nexport interface OrgHierarchyHttpOptions {\n  /** Platform service host/port (+ optional default timeout) for the client. */\n  service: ServiceConfig;\n  /** Service name minted into the service-auth JWT `sub` (e.g. 'compliance'). */\n  serviceName: string;\n  /**\n   * Org id embedded in the signed service token's org context. Defaults to the\n   * queried `orgId`; pass a system org id for a system-scoped lookup.\n   */\n  authOrgId?: string;\n  /** Role carried by the service token (default 'member' — least privilege). */\n  role?: 'owner' | 'admin' | 'member';\n  /** Extra request headers merged after `Authorization` (e.g. `x-org-id`). */\n  headers?: Record<string, string>;\n  /** Per-request timeout override in ms (falls back to the client default). */\n  timeout?: number;\n  /**\n   * When true, a non-2xx response THROWS instead of resolving to `undefined`.\n   * Default false (a 4xx/5xx maps to `undefined`, the fail-soft policy the\n   * message/reporting root-resolution callers rely on). A caller for whom a\n   * failed lookup must fail-CLOSED — e.g. a compliance scan, where treating a\n   * team org as parent-less would silently skip inherited blocking rules — sets\n   * this so it can distinguish \"root org\" (`undefined`) from \"lookup failed\".\n   */\n  throwOnHttpError?: boolean;\n}\n\nfunction buildRequest(\n  orgId: string,\n  suffix: 'parent' | 'descendants',\n  opts: OrgHierarchyHttpOptions,\n): { client: InternalHttpClient; path: string; headers: Record<string, string> } {\n  const client = new InternalHttpClient(opts.service);\n  const path = `/organization/${encodeURIComponent(orgId)}/${suffix}`;\n  const headers: Record<string, string> = {\n    Authorization: getServiceAuthHeader({\n      serviceName: opts.serviceName,\n      orgId: opts.authOrgId ?? orgId,\n      role: opts.role ?? 'member',\n    }),\n    ...opts.headers,\n  };\n  return { client, path, headers };\n}\n\n/**\n * Resolve an org's direct parent id via platform's\n * `GET /organization/:id/parent`. Returns `undefined` for a root org. A non-2xx\n * response resolves to `undefined` by default, or THROWS when\n * `throwOnHttpError` is set. Always throws on a transport failure\n * (connection/timeout) so the caller can apply its own fallback.\n */\nexport async function fetchParentOrgId(orgId: string, opts: OrgHierarchyHttpOptions): Promise<string | undefined> {\n  const { client, path, headers } = buildRequest(orgId, 'parent', opts);\n  const res = await client.get<{ data?: { parentOrgId?: string | null } }>(path, { headers, timeout: opts.timeout });\n  if (res.statusCode >= 400) {\n    if (opts.throwOnHttpError) {\n      throw new Error(`parent-org lookup failed for ${orgId}: HTTP ${res.statusCode}`);\n    }\n    return undefined;\n  }\n  return res.body?.data?.parentOrgId ?? undefined;\n}\n\n/**\n * Resolve `[self, ...descendantOrgIds]` for an org via platform's\n * `GET /organization/:id/descendants`. Returns the id list only when it is\n * larger than the org itself (a real subtree), else `undefined`; also\n * `undefined` on a non-2xx response. Throws on a transport failure so the\n * caller can apply its own fallback.\n *\n * This is a trust boundary: the response is validated element-by-element rather\n * than cast — every entry must be a string, and any non-string is dropped — so\n * a malformed payload can never smuggle a non-string into the returned\n * `string[]`.\n */\nexport async function fetchOrgDescendants(orgId: string, opts: OrgHierarchyHttpOptions): Promise<string[] | undefined> {\n  const { client, path, headers } = buildRequest(orgId, 'descendants', opts);\n  const res = await client.get<{ data?: { orgIds?: unknown } }>(path, { headers, timeout: opts.timeout });\n  if (res.statusCode >= 400) return undefined;\n  const ids = res.body?.data?.orgIds;\n  if (!Array.isArray(ids)) return undefined;\n  const orgIds = ids.filter((id): id is string => typeof id === 'string');\n  // Only meaningful when the (validated) subtree is larger than the org itself.\n  return orgIds.length > 1 ? orgIds : undefined;\n}\n"]}

package/lib/middleware/auth.d.ts

@@ -38,9 +38,17 @@ export interface TokenRevocationStore {
  */
 export declare function setTokenRevocationStore(store: TokenRevocationStore | undefined): void;
 /**
- * Requires admin role. Use after requireAuth.
- * Permits users whose per-org role is 'admin' or 'owner'.
- */
+ * Public revocation check for routes that verify a platform JWT OUTSIDE
+ * `requireAuth` (e.g. the image-registry `/token` mint path, which resolves
+ * identity itself). Returns true when the token's `tokenVersion` is strictly
+ * behind the store's current version. Fail-open (never throws) — a store outage
+ * or a token/store without a usable version yields false (allow), matching
+ * `requireAuth`. Pass the verified JWT claims (`sub`, `tokenVersion`).
+ */
+export declare function isAccessTokenRevoked(claims: {
+    sub?: string;
+    tokenVersion?: number;
+}): Promise<boolean>;
 /**
  * Whether the request's user holds `permission`. Superadmins implicitly hold
  * every permission. Reads the resolved `permissions` claim (set at token issue,
@@ -140,7 +148,8 @@ export declare function isSystemAdmin(req: Request): boolean;
  * identity — a normal interactive user token has no `scope` and returns false.
  */
 export declare function hasScope(req: Request, scope: string): boolean;
-/** Requires system admin (admin role + system organization). */
+/** Requires a system admin — granted solely by the `isSuperAdmin` token claim
+ *  (the org-membership path was removed). Use after requireAuth. */
 export declare function requireSystemAdmin(req: Request, res: Response, next: NextFunction): void;
 /**
  * Require a specific feature flag. Use after requireAuth.
@@ -164,7 +173,9 @@ export declare function resolveAccessModifier(req: Request, requested: string |
 export interface ServiceTokenOptions {
     /** Calling service identifier (e.g. 'billing', 'platform'). Embedded as `sub: service:<name>`. */
     serviceName: string;
-    /** Active org context for the call. Use the target tenant's org ID, or 'system' for system-wide ops. */
+    /** Active org context for the call. Use the target tenant's org id, or the
+     *  well-known `SYSTEM_ORG_ID` (an ObjectId) for system-wide ops — NOT the string
+     *  'system', which id-based system-org checks won't recognize. */
     orgId?: string;
     /** Active org name. Defaults to orgId. */
     orgName?: string;

package/lib/middleware/auth.js

@@ -126,6 +126,17 @@ async function isTokenRevoked(decoded) {
         return false;
     }
 }
+/**
+ * Public revocation check for routes that verify a platform JWT OUTSIDE
+ * `requireAuth` (e.g. the image-registry `/token` mint path, which resolves
+ * identity itself). Returns true when the token's `tokenVersion` is strictly
+ * behind the store's current version. Fail-open (never throws) — a store outage
+ * or a token/store without a usable version yields false (allow), matching
+ * `requireAuth`. Pass the verified JWT claims (`sub`, `tokenVersion`).
+ */
+export async function isAccessTokenRevoked(claims) {
+    return isTokenRevoked(claims);
+}
 function _requireAuth(options, req, res, next) {
     const authHeader = req.headers.authorization;
     if (!authHeader) {
@@ -224,10 +235,6 @@ function _requireAuth(options, req, res, next) {
         return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication failed', ErrorCode.UNAUTHORIZED);
     }
 }
-/**
- * Requires admin role. Use after requireAuth.
- * Permits users whose per-org role is 'admin' or 'owner'.
- */
 /**
  * Whether the request's user holds `permission`. Superadmins implicitly hold
  * every permission. Reads the resolved `permissions` claim (set at token issue,
@@ -351,7 +358,9 @@ export function requirePermissionOrService(...permissions) {
  */
 export function requireServicePrincipal(req, res, next) {
     if (!isServicePrincipal(req)) {
-        return sendError(res, HttpStatus.BAD_REQUEST, 'Internal service calls only', ErrorCode.INSUFFICIENT_PERMISSIONS);
+        // 403 (not 400) — this is an authorization refusal; status must match the
+        // INSUFFICIENT_PERMISSIONS code and the sibling gates (requirePermission, etc.).
+        return sendError(res, HttpStatus.FORBIDDEN, 'Internal service calls only', ErrorCode.INSUFFICIENT_PERMISSIONS);
     }
     next();
 }
@@ -396,7 +405,8 @@ export function isSystemAdmin(req) {
 export function hasScope(req, scope) {
     return req.user?.scope === scope;
 }
-/** Requires system admin (admin role + system organization). */
+/** Requires a system admin — granted solely by the `isSuperAdmin` token claim
+ *  (the org-membership path was removed). Use after requireAuth. */
 export function requireSystemAdmin(req, res, next) {
     if (!isSystemAdmin(req)) {
         auditAuthzDenial(req, 'system-admin');
@@ -532,4 +542,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":"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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 { HttpRequest } from '../types/http.js';\nimport { type Permission, hasPermission } from '../types/permissions.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { getIdentity, type RequestIdentity } from '../utils/identity.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    // Re-derive the request's tenant identity from the NOW-verified JWT.\n    //\n    // `attachRequestContext` runs as a global middleware BEFORE this per-route\n    // `requireAuth`, so it captured `req.context.identity` while `req.user` was\n    // still undefined — at which point `getIdentity` falls back to the raw,\n    // client-settable `x-org-id`/`x-user-id` headers. Every downstream tenant-\n    // authority consumer (requireOrgId, withTenantContext's RLS scope, checkQuota,\n    // withRoute, and the idempotency namespace) reads `req.context.identity`, so\n    // that frozen header-derived value — not the JWT — was governing tenancy on\n    // any non-nginx path. Recomputing here, at the single post-verification choke\n    // point, makes `getIdentity` prefer the verified `req.user` (see identity.ts)\n    // so tenancy is JWT-authoritative. The nginx `x-org-id` overwrite stays as\n    // defence-in-depth. Guarded on `req.context` so services/paths that never\n    // attach a context (or run requireAuth pre-context) are unaffected.\n    const reqCtx = (req as Request & { context?: { identity: RequestIdentity } }).context;\n    if (reqCtx) {\n      reqCtx.identity = getIdentity(req as unknown as HttpRequest);\n    }\n\n    // Session-invalidation 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 */\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      // Strip the query string — a denied request may carry a token/secret as a\n      // query param, and this path is persisted verbatim into the audit log.\n      path: (req.originalUrl || req.url).split('?')[0],\n      required,\n    });\n  } catch {\n    // Best-effort — a broken auditor must never break the auth gate.\n  }\n}\n\n/**\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 * Like {@link requirePermission} (any-of) but ALSO admits an internal service\n * principal (a `service:*` machine token). For READ endpoints that BOTH\n * interactive users — who must hold one of the `:read` capabilities — AND\n * service-to-service callers legitimately hit; service tokens carry no\n * permission claims (they're least-privilege `role:member`), so a plain\n * `requirePermission` would wrongly 403 them. Superadmins pass via\n * `userHasPermission`'s implicit-all. Use only where a service caller is a known,\n * intended consumer of the route (verify the callers); prefer plain\n * `requirePermission` for purely user-facing reads.\n */\nexport function requirePermissionOrService(...permissions: Permission[]) {\n  return (req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\n    if (isServicePrincipal(req) || 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 * Gate an endpoint to internal service-to-service callers only (a `service:*`\n * machine principal minted via {@link signServiceToken} / `getServiceAuthHeader`).\n * Rejects any user token. For NON-user-facing endpoints — entity-event ingest,\n * auto-subscribe, and similar peer-service hooks — that a browser must never\n * reach. Compose after `requireAuth` so `req.user` is populated.\n */\nexport function requireServicePrincipal(req: Request, res: Response, next: NextFunction): void {\n  if (!isServicePrincipal(req)) {\n    return sendError(res, HttpStatus.BAD_REQUEST, 'Internal service calls only', ErrorCode.INSUFFICIENT_PERMISSIONS);\n  }\n  next();\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 only for a caller holding the relevant publish\n * capability (`pipelines:publish` / `plugins:publish`) — superadmins pass via\n * implicit-all. Everyone else (including callers who requested 'public' without\n * the permission, and service principals) gets 'private'.\n *\n * Permission-based (not coarse-role-based): a bespoke custom Role can be granted\n * publish rights and is no longer forced private by its `member` label. Built-in\n * Admin/Owner bundles carry the publish permissions, so their behavior is\n * unchanged; the built-in Member bundle does not, so members stay private-only.\n */\nexport function resolveAccessModifier(\n  req: Request,\n  requested: string | undefined,\n  publishPermission: Permission,\n): 'public' | 'private' {\n  if (requested === 'public' && userHasPermission(req, publishPermission)) {\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// `requireSystemAdmin` 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"]}
+//# 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 { HttpRequest } from '../types/http.js';\nimport { type Permission, hasPermission } from '../types/permissions.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { getIdentity, type RequestIdentity } from '../utils/identity.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\n/**\n * Public revocation check for routes that verify a platform JWT OUTSIDE\n * `requireAuth` (e.g. the image-registry `/token` mint path, which resolves\n * identity itself). Returns true when the token's `tokenVersion` is strictly\n * behind the store's current version. Fail-open (never throws) — a store outage\n * or a token/store without a usable version yields false (allow), matching\n * `requireAuth`. Pass the verified JWT claims (`sub`, `tokenVersion`).\n */\nexport async function isAccessTokenRevoked(claims: { sub?: string; tokenVersion?: number }): Promise<boolean> {\n  return isTokenRevoked(claims as JwtPayload);\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    // Re-derive the request's tenant identity from the NOW-verified JWT.\n    //\n    // `attachRequestContext` runs as a global middleware BEFORE this per-route\n    // `requireAuth`, so it captured `req.context.identity` while `req.user` was\n    // still undefined — at which point `getIdentity` falls back to the raw,\n    // client-settable `x-org-id`/`x-user-id` headers. Every downstream tenant-\n    // authority consumer (requireOrgId, withTenantContext's RLS scope, checkQuota,\n    // withRoute, and the idempotency namespace) reads `req.context.identity`, so\n    // that frozen header-derived value — not the JWT — was governing tenancy on\n    // any non-nginx path. Recomputing here, at the single post-verification choke\n    // point, makes `getIdentity` prefer the verified `req.user` (see identity.ts)\n    // so tenancy is JWT-authoritative. The nginx `x-org-id` overwrite stays as\n    // defence-in-depth. Guarded on `req.context` so services/paths that never\n    // attach a context (or run requireAuth pre-context) are unaffected.\n    const reqCtx = (req as Request & { context?: { identity: RequestIdentity } }).context;\n    if (reqCtx) {\n      reqCtx.identity = getIdentity(req as unknown as HttpRequest);\n    }\n\n    // Session-invalidation 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 * 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      // Strip the query string — a denied request may carry a token/secret as a\n      // query param, and this path is persisted verbatim into the audit log.\n      path: (req.originalUrl || req.url).split('?')[0],\n      required,\n    });\n  } catch {\n    // Best-effort — a broken auditor must never break the auth gate.\n  }\n}\n\n/**\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 * Like {@link requirePermission} (any-of) but ALSO admits an internal service\n * principal (a `service:*` machine token). For READ endpoints that BOTH\n * interactive users — who must hold one of the `:read` capabilities — AND\n * service-to-service callers legitimately hit; service tokens carry no\n * permission claims (they're least-privilege `role:member`), so a plain\n * `requirePermission` would wrongly 403 them. Superadmins pass via\n * `userHasPermission`'s implicit-all. Use only where a service caller is a known,\n * intended consumer of the route (verify the callers); prefer plain\n * `requirePermission` for purely user-facing reads.\n */\nexport function requirePermissionOrService(...permissions: Permission[]) {\n  return (req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\n    if (isServicePrincipal(req) || 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 * Gate an endpoint to internal service-to-service callers only (a `service:*`\n * machine principal minted via {@link signServiceToken} / `getServiceAuthHeader`).\n * Rejects any user token. For NON-user-facing endpoints — entity-event ingest,\n * auto-subscribe, and similar peer-service hooks — that a browser must never\n * reach. Compose after `requireAuth` so `req.user` is populated.\n */\nexport function requireServicePrincipal(req: Request, res: Response, next: NextFunction): void {\n  if (!isServicePrincipal(req)) {\n    // 403 (not 400) — this is an authorization refusal; status must match the\n    // INSUFFICIENT_PERMISSIONS code and the sibling gates (requirePermission, etc.).\n    return sendError(res, HttpStatus.FORBIDDEN, 'Internal service calls only', ErrorCode.INSUFFICIENT_PERMISSIONS);\n  }\n  next();\n}\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 a system admin — granted solely by the `isSuperAdmin` token claim\n *  (the org-membership path was removed). Use after requireAuth. */\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 only for a caller holding the relevant publish\n * capability (`pipelines:publish` / `plugins:publish`) — superadmins pass via\n * implicit-all. Everyone else (including callers who requested 'public' without\n * the permission, and service principals) gets 'private'.\n *\n * Permission-based (not coarse-role-based): a bespoke custom Role can be granted\n * publish rights and is no longer forced private by its `member` label. Built-in\n * Admin/Owner bundles carry the publish permissions, so their behavior is\n * unchanged; the built-in Member bundle does not, so members stay private-only.\n */\nexport function resolveAccessModifier(\n  req: Request,\n  requested: string | undefined,\n  publishPermission: Permission,\n): 'public' | 'private' {\n  if (requested === 'public' && userHasPermission(req, publishPermission)) {\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// `requireSystemAdmin` 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 the\n   *  well-known `SYSTEM_ORG_ID` (an ObjectId) for system-wide ops — NOT the string\n   *  'system', which id-based system-org checks won't recognize. */\n  orgId?: string;\n  /** Active org name. Defaults to orgId. */\n  orgName?: string;\n  /** TTL in seconds (default 300). */\n  ttlSeconds?: number;\n  /**\n   * Role the token carries (required — no implicit default). **Pass the LOWEST\n   * role the call actually needs** (`'member'` for read / data-plane calls) so a\n   * leaked service token can't perform admin actions in the target org.\n   * `isAdmin` is derived from this (admin|owner → true).\n   */\n  role: 'owner' | 'admin' | 'member';\n}\n\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/audit-spool.d.ts

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