@pipeline-builder/api-core 4.1.12 → 4.1.14

package/lib/middleware/ecosystem-guard.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The plugin-ecosystem governance gate (docs/runbooks/ecosystem-moderation.md).
+ *
+ * Only the system org manages or approves the ecosystem. A route that exercises
+ * a system-org-only permission (`plugins:moderate`, `publishers:verify`) must
+ * therefore check three things, and {@link requireEcosystemPermission} composes
+ * them so no route can forget one:
+ *
+ *  1. {@link requireSystemOrg} — the caller's ACTIVE org is the system org. A
+ *     token minted in a tenant org is refused even for the same person (and even
+ *     for a superadmin: they switch to the system org to act on the ecosystem,
+ *     so every governance decision is recorded with the system org's id).
+ *  2. the permission itself (`requirePermission`, any-of);
+ *  3. an MFA-grade session (`requireAssurance({ minAssurance: 2 })`), which also
+ *     refuses every machine credential.
+ *
+ * The route-coverage governance check (`findSystemOrgGuardViolations` in
+ * `testing/route-coverage.ts`) fails any route that gates on a system-org-only
+ * permission without 1 and 3, so a hand-rolled chain cannot slip through.
+ */
+import type { NextFunction, Request, RequestHandler, Response } from 'express';
+import { type Permission } from '../types/permissions.js';
+/** Whether the request's ACTIVE org (the token's `organizationId`) is the system
+ *  org. Compared by id only — an org merely NAMED "system" never qualifies. */
+export declare function isSystemOrgRequest(req: Request): boolean;
+/**
+ * Require that the caller's active org is the system org. Compose after
+ * `requireAuth`. Refusals are 403 `SYSTEM_ORG_REQUIRED`, counted
+ * (`system_org_guard_refused_total`) and audited through the shared
+ * `authz.denied` sink (`required: 'system-org'`).
+ */
+export declare const requireSystemOrg: (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * THE gate for an ecosystem-governance route: system org + (any of) the given
+ * system-org-only permission(s) + an MFA-grade human session. Returns the chain
+ * as an array, which Express flattens:
+ *
+ * ```ts
+ * router.post('/requests/:id/approve', requireAuth, requireEcosystemPermission('plugins:moderate'),
+ *   requireStepUp, audited('plugin.request.approve'), handler);
+ * ```
+ *
+ * Throws at route-definition time when handed a permission that is NOT
+ * system-org-only — a tenant permission behind this gate would be unreachable
+ * for every tenant, which is always a wiring mistake.
+ */
+export declare function requireEcosystemPermission(...permissions: Permission[]): RequestHandler[];

package/lib/middleware/ecosystem-guard.js

@@ -0,0 +1,60 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { isSystemOrgId } from './system-org.js';
+import { recordAuthzDenial, requirePermission } from './permission-gates.js';
+import { requireAssurance } from './assurance.js';
+import { tagRouteGate } from './route-table.js';
+import { HttpStatus } from '../constants/http-status.js';
+import { ErrorCode } from '../types/error-codes.js';
+import { isSystemOrgOnlyPermission } from '../types/permissions.js';
+import { emitCounter } from '../utils/metric-emitter.js';
+import { sendError } from '../utils/response.js';
+/** Whether the request's ACTIVE org (the token's `organizationId`) is the system
+ *  org. Compared by id only — an org merely NAMED "system" never qualifies. */
+export function isSystemOrgRequest(req) {
+    return isSystemOrgId(req.user?.organizationId);
+}
+/**
+ * Require that the caller's active org is the system org. Compose after
+ * `requireAuth`. Refusals are 403 `SYSTEM_ORG_REQUIRED`, counted
+ * (`system_org_guard_refused_total`) and audited through the shared
+ * `authz.denied` sink (`required: 'system-org'`).
+ */
+export const requireSystemOrg = tagRouteGate(function requireSystemOrg(req, res, next) {
+    if (!req.user) {
+        return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);
+    }
+    if (isSystemOrgRequest(req))
+        return next();
+    emitCounter('system_org_guard_refused_total', { principal: req.user.principalType ?? 'unknown' });
+    recordAuthzDenial(req, 'system-org');
+    return sendError(res, HttpStatus.FORBIDDEN, 'This action is reserved for the system organization — switch to it to manage the plugin ecosystem', ErrorCode.SYSTEM_ORG_REQUIRED);
+}, { kind: 'systemOrg' });
+/**
+ * THE gate for an ecosystem-governance route: system org + (any of) the given
+ * system-org-only permission(s) + an MFA-grade human session. Returns the chain
+ * as an array, which Express flattens:
+ *
+ * ```ts
+ * router.post('/requests/:id/approve', requireAuth, requireEcosystemPermission('plugins:moderate'),
+ *   requireStepUp, audited('plugin.request.approve'), handler);
+ * ```
+ *
+ * Throws at route-definition time when handed a permission that is NOT
+ * system-org-only — a tenant permission behind this gate would be unreachable
+ * for every tenant, which is always a wiring mistake.
+ */
+export function requireEcosystemPermission(...permissions) {
+    if (permissions.length === 0)
+        throw new Error('requireEcosystemPermission needs at least one permission');
+    const tenant = permissions.filter((p) => !isSystemOrgOnlyPermission(p));
+    if (tenant.length > 0) {
+        throw new Error(`requireEcosystemPermission only takes system-org-only permissions; got ${tenant.join(', ')}`);
+    }
+    return [
+        requireSystemOrg,
+        requirePermission(...permissions),
+        requireAssurance({ minAssurance: 2 }),
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecosystem-guard.js","sourceRoot":"","sources":["../../src/middleware/ecosystem-guard.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAwBtC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC7E,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,yBAAyB,EAAmB,MAAM,yBAAyB,CAAC;AACrF,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD;+EAC+E;AAC/E,MAAM,UAAU,kBAAkB,CAAC,GAAY;IAC7C,OAAO,aAAa,CAAC,GAAG,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;AACjD,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,YAAY,CAAC,SAAS,gBAAgB,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB;IACpH,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;IACD,IAAI,kBAAkB,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,EAAE,CAAC;IAC3C,WAAW,CAAC,gCAAgC,EAAE,EAAE,SAAS,EAAE,GAAG,CAAC,IAAI,CAAC,aAAa,IAAI,SAAS,EAAE,CAAC,CAAC;IAClG,iBAAiB,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;IACrC,OAAO,SAAS,CACd,GAAG,EAAE,UAAU,CAAC,SAAS,EACzB,mGAAmG,EACnG,SAAS,CAAC,mBAAmB,CAC9B,CAAC;AACJ,CAAC,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC;AAE1B;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,0BAA0B,CAAC,GAAG,WAAyB;IACrE,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;IAC1G,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC,CAAC;IACxE,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,0EAA0E,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACjH,CAAC;IACD,OAAO;QACL,gBAAgB;QAChB,iBAAiB,CAAC,GAAG,WAAW,CAAC;QACjC,gBAAgB,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,CAAC;KAClB,CAAC;AACxB,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The plugin-ecosystem governance gate (docs/runbooks/ecosystem-moderation.md).\n *\n * Only the system org manages or approves the ecosystem. A route that exercises\n * a system-org-only permission (`plugins:moderate`, `publishers:verify`) must\n * therefore check three things, and {@link requireEcosystemPermission} composes\n * them so no route can forget one:\n *\n *  1. {@link requireSystemOrg} — the caller's ACTIVE org is the system org. A\n *     token minted in a tenant org is refused even for the same person (and even\n *     for a superadmin: they switch to the system org to act on the ecosystem,\n *     so every governance decision is recorded with the system org's id).\n *  2. the permission itself (`requirePermission`, any-of);\n *  3. an MFA-grade session (`requireAssurance({ minAssurance: 2 })`), which also\n *     refuses every machine credential.\n *\n * The route-coverage governance check (`findSystemOrgGuardViolations` in\n * `testing/route-coverage.ts`) fails any route that gates on a system-org-only\n * permission without 1 and 3, so a hand-rolled chain cannot slip through.\n */\n\nimport type { NextFunction, Request, RequestHandler, Response } from 'express';\nimport { isSystemOrgId } from './system-org.js';\nimport { recordAuthzDenial, requirePermission } from './permission-gates.js';\nimport { requireAssurance } from './assurance.js';\nimport { tagRouteGate } from './route-table.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { isSystemOrgOnlyPermission, type Permission } from '../types/permissions.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { sendError } from '../utils/response.js';\n\n/** Whether the request's ACTIVE org (the token's `organizationId`) is the system\n *  org. Compared by id only — an org merely NAMED \"system\" never qualifies. */\nexport function isSystemOrgRequest(req: Request): boolean {\n  return isSystemOrgId(req.user?.organizationId);\n}\n\n/**\n * Require that the caller's active org is the system org. Compose after\n * `requireAuth`. Refusals are 403 `SYSTEM_ORG_REQUIRED`, counted\n * (`system_org_guard_refused_total`) and audited through the shared\n * `authz.denied` sink (`required: 'system-org'`).\n */\nexport const requireSystemOrg = tagRouteGate(function requireSystemOrg(req: Request, res: Response, next: NextFunction): void {\n  if (!req.user) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n  }\n  if (isSystemOrgRequest(req)) return next();\n  emitCounter('system_org_guard_refused_total', { principal: req.user.principalType ?? 'unknown' });\n  recordAuthzDenial(req, 'system-org');\n  return sendError(\n    res, HttpStatus.FORBIDDEN,\n    'This action is reserved for the system organization — switch to it to manage the plugin ecosystem',\n    ErrorCode.SYSTEM_ORG_REQUIRED,\n  );\n}, { kind: 'systemOrg' });\n\n/**\n * THE gate for an ecosystem-governance route: system org + (any of) the given\n * system-org-only permission(s) + an MFA-grade human session. Returns the chain\n * as an array, which Express flattens:\n *\n * ```ts\n * router.post('/requests/:id/approve', requireAuth, requireEcosystemPermission('plugins:moderate'),\n *   requireStepUp, audited('plugin.request.approve'), handler);\n * ```\n *\n * Throws at route-definition time when handed a permission that is NOT\n * system-org-only — a tenant permission behind this gate would be unreachable\n * for every tenant, which is always a wiring mistake.\n */\nexport function requireEcosystemPermission(...permissions: Permission[]): RequestHandler[] {\n  if (permissions.length === 0) throw new Error('requireEcosystemPermission needs at least one permission');\n  const tenant = permissions.filter((p) => !isSystemOrgOnlyPermission(p));\n  if (tenant.length > 0) {\n    throw new Error(`requireEcosystemPermission only takes system-org-only permissions; got ${tenant.join(', ')}`);\n  }\n  return [\n    requireSystemOrg,\n    requirePermission(...permissions),\n    requireAssurance({ minAssurance: 2 }),\n  ] as RequestHandler[];\n}\n"]}

package/lib/middleware/index.d.ts

@@ -1,4 +1,11 @@
-export * from './auth.js';
-export * from './mongo-sanitize.js';
-export * from './step-up.js';
-export * from './route-table.js';
+export { verifyUserJwt, verifyBearerToken, hasValidIdentityClaims, } from './jwt-verify.js';
+export { requireAuth, } from './auth.js';
+export { setTokenRevocationStore, isAccessTokenRevoked, } from './revocation.js';
+export { requireAssurance, refuseWeakSession, refuseForOrgAdminAssurance, requireOrgAdminAssurance, type AssuranceOptions, } from './assurance.js';
+export { userHasPermission, setAuthzDenialAuditor, recordAuthzDenial, requirePermission, requireAllPermissions, requirePermissionOrService, requireServicePrincipal, requireInternalService, isSystemAdmin, hasScope, requireSystemAdmin, requireFeature, type AuthzDenialInfo, } from './permission-gates.js';
+export { isSystemOrgId, SYSTEM_ORG_ID, SYSTEM_ORG_SLUG, } from './system-org.js';
+export { serviceNameOf, isServiceTokenDenied, signServiceToken, getServiceAuthHeader, isServicePrincipal, isServiceAccountPrincipal, isServicePrincipalNamed, verifyServicePrincipal, } from './service-tokens.js';
+export { requireSystemOrg, requireEcosystemPermission } from './ecosystem-guard.js';
+export { mongoSanitize, MAX_SANITIZE_DEPTH, } from './mongo-sanitize.js';
+export { requireStepUp, type StepUpMethod, STRONG_STEP_UP_METHODS, } from './step-up.js';
+export { tagRouteGate, getRouteGates, audited, buildRouteTable, isWriteMethod, summarizeRouteTable, type RouteTableEntry, } from './route-table.js';

package/lib/middleware/index.js

@@ -1,7 +1,14 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-export * from './auth.js';
-export * from './mongo-sanitize.js';
-export * from './step-up.js';
-export * from './route-table.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWlkZGxld2FyZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG5leHBvcnQgKiBmcm9tICcuL2F1dGguanMnO1xuZXhwb3J0ICogZnJvbSAnLi9tb25nby1zYW5pdGl6ZS5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3N0ZXAtdXAuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9yb3V0ZS10YWJsZS5qcyc7XG4iXX0=
+export { verifyUserJwt, verifyBearerToken, hasValidIdentityClaims, } from './jwt-verify.js';
+export { requireAuth, } from './auth.js';
+export { setTokenRevocationStore, isAccessTokenRevoked, } from './revocation.js';
+export { requireAssurance, refuseWeakSession, refuseForOrgAdminAssurance, requireOrgAdminAssurance, } from './assurance.js';
+export { userHasPermission, setAuthzDenialAuditor, recordAuthzDenial, requirePermission, requireAllPermissions, requirePermissionOrService, requireServicePrincipal, requireInternalService, isSystemAdmin, hasScope, requireSystemAdmin, requireFeature, } from './permission-gates.js';
+export { isSystemOrgId, SYSTEM_ORG_ID, SYSTEM_ORG_SLUG, } from './system-org.js';
+export { serviceNameOf, isServiceTokenDenied, signServiceToken, getServiceAuthHeader, isServicePrincipal, isServiceAccountPrincipal, isServicePrincipalNamed, verifyServicePrincipal, } from './service-tokens.js';
+export { requireSystemOrg, requireEcosystemPermission } from './ecosystem-guard.js';
+export { mongoSanitize, MAX_SANITIZE_DEPTH, } from './mongo-sanitize.js';
+export { requireStepUp, STRONG_STEP_UP_METHODS, } from './step-up.js';
+export { tagRouteGate, getRouteGates, audited, buildRouteTable, isWriteMethod, summarizeRouteTable, } from './route-table.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWlkZGxld2FyZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLE9BQU8sRUFDTCxhQUFhLEVBQ2IsaUJBQWlCLEVBQ2pCLHNCQUFzQixHQUN2QixNQUFNLGlCQUFpQixDQUFDO0FBQ3pCLE9BQU8sRUFDTCxXQUFXLEdBQ1osTUFBTSxXQUFXLENBQUM7QUFDbkIsT0FBTyxFQUNMLHVCQUF1QixFQUN2QixvQkFBb0IsR0FDckIsTUFBTSxpQkFBaUIsQ0FBQztBQUN6QixPQUFPLEVBQ0wsZ0JBQWdCLEVBQ2hCLGlCQUFpQixFQUNqQiwwQkFBMEIsRUFDMUIsd0JBQXdCLEdBRXpCLE1BQU0sZ0JBQWdCLENBQUM7QUFDeEIsT0FBTyxFQUNMLGlCQUFpQixFQUNqQixxQkFBcUIsRUFDckIsaUJBQWlCLEVBQ2pCLGlCQUFpQixFQUNqQixxQkFBcUIsRUFDckIsMEJBQTBCLEVBQzFCLHVCQUF1QixFQUN2QixzQkFBc0IsRUFDdEIsYUFBYSxFQUNiLFFBQVEsRUFDUixrQkFBa0IsRUFDbEIsY0FBYyxHQUVmLE1BQU0sdUJBQXVCLENBQUM7QUFDL0IsT0FBTyxFQUNMLGFBQWEsRUFDYixhQUFhLEVBQ2IsZUFBZSxHQUNoQixNQUFNLGlCQUFpQixDQUFDO0FBQ3pCLE9BQU8sRUFDTCxhQUFhLEVBQ2Isb0JBQW9CLEVBQ3BCLGdCQUFnQixFQUNoQixvQkFBb0IsRUFDcEIsa0JBQWtCLEVBQ2xCLHlCQUF5QixFQUN6Qix1QkFBdUIsRUFDdkIsc0JBQXNCLEdBQ3ZCLE1BQU0scUJBQXFCLENBQUM7QUFDN0IsT0FBTyxFQUFFLGdCQUFnQixFQUFFLDBCQUEwQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDcEYsT0FBTyxFQUNMLGFBQWEsRUFDYixrQkFBa0IsR0FDbkIsTUFBTSxxQkFBcUIsQ0FBQztBQUM3QixPQUFPLEVBQ0wsYUFBYSxFQUViLHNCQUFzQixHQUN2QixNQUFNLGNBQWMsQ0FBQztBQUN0QixPQUFPLEVBQ0wsWUFBWSxFQUNaLGFBQWEsRUFDYixPQUFPLEVBQ1AsZUFBZSxFQUNmLGFBQWEsRUFDYixtQkFBbUIsR0FFcEIsTUFBTSxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG5leHBvcnQge1xuICB2ZXJpZnlVc2VySnd0LFxuICB2ZXJpZnlCZWFyZXJUb2tlbixcbiAgaGFzVmFsaWRJZGVudGl0eUNsYWltcyxcbn0gZnJvbSAnLi9qd3QtdmVyaWZ5LmpzJztcbmV4cG9ydCB7XG4gIHJlcXVpcmVBdXRoLFxufSBmcm9tICcuL2F1dGguanMnO1xuZXhwb3J0IHtcbiAgc2V0VG9rZW5SZXZvY2F0aW9uU3RvcmUsXG4gIGlzQWNjZXNzVG9rZW5SZXZva2VkLFxufSBmcm9tICcuL3Jldm9jYXRpb24uanMnO1xuZXhwb3J0IHtcbiAgcmVxdWlyZUFzc3VyYW5jZSxcbiAgcmVmdXNlV2Vha1Nlc3Npb24sXG4gIHJlZnVzZUZvck9yZ0FkbWluQXNzdXJhbmNlLFxuICByZXF1aXJlT3JnQWRtaW5Bc3N1cmFuY2UsXG4gIHR5cGUgQXNzdXJhbmNlT3B0aW9ucyxcbn0gZnJvbSAnLi9hc3N1cmFuY2UuanMnO1xuZXhwb3J0IHtcbiAgdXNlckhhc1Blcm1pc3Npb24sXG4gIHNldEF1dGh6RGVuaWFsQXVkaXRvcixcbiAgcmVjb3JkQXV0aHpEZW5pYWwsXG4gIHJlcXVpcmVQZXJtaXNzaW9uLFxuICByZXF1aXJlQWxsUGVybWlzc2lvbnMsXG4gIHJlcXVpcmVQZXJtaXNzaW9uT3JTZXJ2aWNlLFxuICByZXF1aXJlU2VydmljZVByaW5jaXBhbCxcbiAgcmVxdWlyZUludGVybmFsU2VydmljZSxcbiAgaXNTeXN0ZW1BZG1pbixcbiAgaGFzU2NvcGUsXG4gIHJlcXVpcmVTeXN0ZW1BZG1pbixcbiAgcmVxdWlyZUZlYXR1cmUsXG4gIHR5cGUgQXV0aHpEZW5pYWxJbmZvLFxufSBmcm9tICcuL3Blcm1pc3Npb24tZ2F0ZXMuanMnO1xuZXhwb3J0IHtcbiAgaXNTeXN0ZW1PcmdJZCxcbiAgU1lTVEVNX09SR19JRCxcbiAgU1lTVEVNX09SR19TTFVHLFxufSBmcm9tICcuL3N5c3RlbS1vcmcuanMnO1xuZXhwb3J0IHtcbiAgc2VydmljZU5hbWVPZixcbiAgaXNTZXJ2aWNlVG9rZW5EZW5pZWQsXG4gIHNpZ25TZXJ2aWNlVG9rZW4sXG4gIGdldFNlcnZpY2VBdXRoSGVhZGVyLFxuICBpc1NlcnZpY2VQcmluY2lwYWwsXG4gIGlzU2VydmljZUFjY291bnRQcmluY2lwYWwsXG4gIGlzU2VydmljZVByaW5jaXBhbE5hbWVkLFxuICB2ZXJpZnlTZXJ2aWNlUHJpbmNpcGFsLFxufSBmcm9tICcuL3NlcnZpY2UtdG9rZW5zLmpzJztcbmV4cG9ydCB7IHJlcXVpcmVTeXN0ZW1PcmcsIHJlcXVpcmVFY29zeXN0ZW1QZXJtaXNzaW9uIH0gZnJvbSAnLi9lY29zeXN0ZW0tZ3VhcmQuanMnO1xuZXhwb3J0IHtcbiAgbW9uZ29TYW5pdGl6ZSxcbiAgTUFYX1NBTklUSVpFX0RFUFRILFxufSBmcm9tICcuL21vbmdvLXNhbml0aXplLmpzJztcbmV4cG9ydCB7XG4gIHJlcXVpcmVTdGVwVXAsXG4gIHR5cGUgU3RlcFVwTWV0aG9kLFxuICBTVFJPTkdfU1RFUF9VUF9NRVRIT0RTLFxufSBmcm9tICcuL3N0ZXAtdXAuanMnO1xuZXhwb3J0IHtcbiAgdGFnUm91dGVHYXRlLFxuICBnZXRSb3V0ZUdhdGVzLFxuICBhdWRpdGVkLFxuICBidWlsZFJvdXRlVGFibGUsXG4gIGlzV3JpdGVNZXRob2QsXG4gIHN1bW1hcml6ZVJvdXRlVGFibGUsXG4gIHR5cGUgUm91dGVUYWJsZUVudHJ5LFxufSBmcm9tICcuL3JvdXRlLXRhYmxlLmpzJztcbiJdfQ==

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

@@ -0,0 +1,52 @@
+import { type JwtPayload } from '../types/common.js';
+/** Issuer/audience pinning, when the deployment configures them. Shared by both chains. */
+export declare function issuerAudienceOptions(): {
+    issuer?: string;
+    audience?: string;
+};
+/**
+ * Verify a token that speaks for a PERSON — access, step-up, and the token an
+ * opaque access key is exchanged for — against platform's published signing
+ * keys.
+ *
+ * ES256 and a `kid` are both mandatory: no `kid` means no way to pick the right
+ * key across a rotation, and any other algorithm is refused outright, which is
+ * what makes "no service accepts an HS256 user token" a property of the code
+ * rather than a convention. Key lookup goes through the shared JWKS cache
+ * (10-minute refresh, one refetch on an unknown `kid`, brief negative cache).
+ *
+ * @throws {UnknownKidError} the key set is current and has no such key → 401.
+ * @throws {JwksUnavailableError} the key set could not be obtained → 503; an
+ *         unverifiable token is never treated as valid.
+ */
+export declare function verifyUserJwt<T = JwtPayload>(token: string): Promise<T>;
+/**
+ * Verify ANY bearer token and return its claims.
+ *
+ * Since #14 there is no shared secret left: BOTH chains are ES256 with a `kid`,
+ * so the dispatch is by **who owns the `kid`** rather than by algorithm — and
+ * because a `kid` is an RFC 7638 thumbprint, ownership is a fact about the key,
+ * not a claim the token makes about itself:
+ *
+ * - a `kid` published in the per-service key bundle → an INTERNAL SERVICE token
+ *   ({@link signServiceToken}), verified with that service's key; its `sub` must
+ *   name the same service, so one service can never speak for another.
+ * - anything else → a platform-signed USER token, verified against platform's
+ *   published JWKS. A token claiming `principalType: 'service'` is refused
+ *   here: an internal identity may not ride the user signing key.
+ *
+ * Anything that is not ES256 with a `kid` fails in both chains, which is what
+ * makes "no HS256 token is accepted anywhere" a property of the code.
+ */
+export declare function verifyBearerToken(token: string): Promise<JwtPayload>;
+/**
+ * Whether a verified token carries a well-formed identity: a known
+ * `principalType` and `token_use`, and the claims that kind of principal must
+ * have. Fails closed — a token minted before these claims existed, or one with a
+ * contradictory combination, is not an identity any gate should reason about.
+ *
+ * - `service`: `token_use: 'access'` and a `service:<name>` subject (the name
+ *   feeds the denylist and audit attribution).
+ * - `user` / `service_account`: `amr` (known methods), `aal` and `auth_time`.
+ */
+export declare function hasValidIdentityClaims(decoded: Partial<JwtPayload>): boolean;

package/lib/middleware/jwt-verify.js

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

package/lib/middleware/permission-gates.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Authorization gates — permissions, system admin, features — and the
+ * `authz.denied` audit sink they report refusals to.
+ */
+import type { Request, Response, NextFunction } from 'express';
+import { type Permission } from '../types/permissions.js';
+/**
+ * Whether the request's user holds `permission`. Superadmins implicitly hold
+ * every permission. Reads the resolved `permissions` claim (set at token issue,
+ * or re-derived per request by the platform).
+ */
+export 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;
+/**
+ * Emit a denial event, best-effort. Only fires for state-changing (non-GET,
+ * non-HEAD/OPTIONS) requests — a rejected GET is low-signal probing noise and
+ * would amplify audit volume under a scan. Never throws.
+ *
+ * The permission gates here call it themselves. Export it for data-driven checks
+ * a route makes inline (cross-org access, service-only endpoints), so those 403s
+ * reach the same `authz.denied` trail. `required` names what was missing.
+ */
+export declare function recordAuthzDenial(req: Request, required: string): 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;
+ * pass a single permission for a specific action, or several when any one of
+ * 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;
+/**
+ * Like {@link requirePermission} (any-of) but ALSO admits an internal service
+ * principal (`principalType: 'service'`). For READ endpoints that BOTH
+ * interactive users — who must hold one of the `:read` capabilities — AND
+ * service-to-service callers legitimately hit; service tokens carry no
+ * permission claims (they're least-privilege `role:member`), so a plain
+ * `requirePermission` would wrongly 403 them. Superadmins pass via
+ * `userHasPermission`'s implicit-all. Use only where a service caller is a known,
+ * intended consumer of the route (verify the callers); prefer plain
+ * `requirePermission` for purely user-facing reads.
+ */
+export declare function requirePermissionOrService(...permissions: Permission[]): (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Gate an endpoint to internal service-to-service callers only (a
+ * `principalType: 'service'` principal minted via {@link signServiceToken} / `getServiceAuthHeader`).
+ * Rejects any user token. For NON-user-facing endpoints — entity-event ingest,
+ * auto-subscribe, and similar peer-service hooks — that a browser must never
+ * reach. Compose after `requireAuth` so `req.user` is populated.
+ */
+export declare function requireServicePrincipal(req: Request, res: Response, next: NextFunction): void;
+/**
+ * THE gate for an INTERNAL route — the one every `/internal/*` path, the
+ * quota usage counters, the entity-event ingest and the audit ingest go through.
+ *
+ * Two rules, both fail-closed:
+ *
+ *  1. **No user token, ever.** Not a member's, not a superadmin's, not a
+ *     service-account key's. An internal route is a peer-service API surface, so
+ *     "a sufficiently privileged human" is not an acceptable caller — that
+ *     equivalence is exactly how a browser-reachable path becomes a tenant
+ *     boundary bug. `requireServicePrincipal` already refused users; this also
+ *     closes the `|| isSystemAdmin(req)` escape hatches that had grown around
+ *     the individual internal routes.
+ *  2. **Only the NAMED callers.** `callers` lists the services that legitimately
+ *     call this route, and the name is cryptographically bound to the signing
+ *     key (`services/service-keys.ts`), so this is an identity check rather than
+ *     a claim check. It is the same allow-list the mesh policy names, at the
+ *     layer that also holds in docker compose, where there is no mesh at all —
+ *     the Istio `AuthorizationPolicy` is defence in depth on top, never the
+ *     enforcement.
+ *
+ * Compose after `requireAuth` so `req.user` is populated. Refusals are counted
+ * (`internal_route_refused_total`) and audited through the shared `authz.denied`
+ * sink.
+ */
+export declare function requireInternalService(options: {
+    callers: readonly string[];
+}): (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Check if the request is from a system admin.
+ *
+ * Authority is granted solely by the user-level `isSuperAdmin` flag carried
+ * in the JWT — never by membership in the well-known 'system' org, which would
+ * conflate a Pipeline Builder operator with a customer tenant and let any
+ * write that created a 'system'-named org quietly grant cross-org authority. The `system` org still exists as a *content holder* for shared
+ * sample data; it confers no privilege.
+ */
+export declare function isSystemAdmin(req: Request): boolean;
+/**
+ * Whether the request's token carries a specific capability `scope` (e.g.
+ * `'reporting:ingest'`). Used to gate endpoints that accept a narrow machine
+ * identity — a normal interactive user token has no `scope` and returns false.
+ */
+export declare function hasScope(req: Request, scope: string): boolean;
+/** Requires a system admin — granted solely by the `isSuperAdmin` token claim.
+ *  Use after requireAuth. */
+export declare function requireSystemAdmin(req: Request, res: Response, next: NextFunction): void;
+/**
+ * Require a specific feature flag. Use after requireAuth.
+ * Checks the `features` array in the JWT payload (set at token issuance).
+ * Sysadmins (isSuperAdmin) bypass — they always have every feature.
+ */
+export declare function requireFeature(feature: string): (req: Request, res: Response, next: NextFunction) => void;