@pipeline-builder/api-core 5.2.3 → 5.2.4

package/lib/middleware/deferred-quota-check.d.ts

@@ -0,0 +1,5 @@
+import type { NextFunction, Request, RequestHandler, Response } from 'express';
+/** Arm `check` to run after this request authenticates. */
+export declare function armDeferredQuotaCheck(res: Response, check: RequestHandler): void;
+/** `requireAuth`'s `next()`: run the armed quota check, if any, then continue. */
+export declare function runDeferredQuotaCheck(req: Request, res: Response, next: NextFunction): void;

package/lib/middleware/deferred-quota-check.js

@@ -0,0 +1,33 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * A quota check armed at MOUNT time and run by `requireAuth` once the caller is
+ * verified.
+ *
+ * Why deferred: the apiCalls meter + check mount ONCE per service, ahead of its
+ * whole user surface (api-server `apiCallsQuota`), but authentication is per
+ * route — routers mix public, user and machine routes under one prefix. At mount
+ * time there is no verified org to check yet, and checking a header-derived or
+ * peeked one would hand a forged token a victim org's usage in the 429 body. So
+ * the mount only ARMS the check here, and `requireAuth` (api-core's, and
+ * platform's own) runs it at its single post-verification choke point, after
+ * the request identity has been re-derived from the JWT. A route that never
+ * authenticates never runs it — there is no org to bill.
+ *
+ * At most once per request: running it empties the slot, so a second
+ * `requireAuth` in the same chain is a plain `next()`.
+ */
+const SLOT = 'deferredQuotaCheck';
+/** Arm `check` to run after this request authenticates. */
+export function armDeferredQuotaCheck(res, check) {
+    res.locals[SLOT] = check;
+}
+/** `requireAuth`'s `next()`: run the armed quota check, if any, then continue. */
+export function runDeferredQuotaCheck(req, res, next) {
+    const check = res.locals?.[SLOT];
+    if (!check)
+        return next();
+    delete res.locals[SLOT];
+    void check(req, res, next);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -3,7 +3,7 @@
  *
  * 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
+ * therefore check three things, and {@link requireSystemOrgPermission} composes
  * them so no route can forget one:
  *
  *  1. {@link requireSystemOrg} — the caller's ACTIVE org is the system org. A
@@ -36,7 +36,7 @@ export declare const requireSystemOrg: (req: Request, res: Response, next: NextF
  * as an array, which Express flattens:
  *
  * ```ts
- * router.post('/requests/:id/approve', requireAuth, requireEcosystemPermission('plugins:moderate'),
+ * router.post('/requests/:id/approve', requireAuth, requireSystemOrgPermission('plugins:moderate'),
  *   requireStepUp, audited('plugin.request.approve'), handler);
  * ```
  *
@@ -44,4 +44,4 @@ export declare const requireSystemOrg: (req: Request, res: Response, next: NextF
  * 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[];
+export declare function requireSystemOrgPermission(...permissions: Permission[]): RequestHandler[];

package/lib/middleware/ecosystem-guard.js

@@ -36,7 +36,7 @@ export const requireSystemOrg = tagRouteGate(function requireSystemOrg(req, res,
  * as an array, which Express flattens:
  *
  * ```ts
- * router.post('/requests/:id/approve', requireAuth, requireEcosystemPermission('plugins:moderate'),
+ * router.post('/requests/:id/approve', requireAuth, requireSystemOrgPermission('plugins:moderate'),
  *   requireStepUp, audited('plugin.request.approve'), handler);
  * ```
  *
@@ -44,12 +44,12 @@ export const requireSystemOrg = tagRouteGate(function requireSystemOrg(req, res,
  * 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) {
+export function requireSystemOrgPermission(...permissions) {
     if (permissions.length === 0)
-        throw new Error('requireEcosystemPermission needs at least one permission');
+        throw new Error('requireSystemOrgPermission 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(', ')}`);
+        throw new Error(`requireSystemOrgPermission only takes system-org-only permissions; got ${tenant.join(', ')}`);
     }
     return [
         requireSystemOrg,
@@ -57,4 +57,4 @@ export function requireEcosystemPermission(...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,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC7E,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,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 { requireAssurance } from './assurance.js';\nimport { recordAuthzDenial, requirePermission } from './permission-gates.js';\nimport { tagRouteGate } from './route-table.js';\nimport { isSystemOrgId } from './system-org.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"]}
+//# 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,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC7E,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,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 requireSystemOrgPermission} 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 { requireAssurance } from './assurance.js';\nimport { recordAuthzDenial, requirePermission } from './permission-gates.js';\nimport { tagRouteGate } from './route-table.js';\nimport { isSystemOrgId } from './system-org.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, requireSystemOrgPermission('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 requireSystemOrgPermission(...permissions: Permission[]): RequestHandler[] {\n  if (permissions.length === 0) throw new Error('requireSystemOrgPermission needs at least one permission');\n  const tenant = permissions.filter((p) => !isSystemOrgOnlyPermission(p));\n  if (tenant.length > 0) {\n    throw new Error(`requireSystemOrgPermission 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

@@ -5,8 +5,11 @@ export { requireAssurance, refuseWeakSession, refuseForOrgAdminAssurance, requir
 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 { requireSystemOrg, requireSystemOrgPermission } from './ecosystem-guard.js';
 export { mongoSanitize, MAX_SANITIZE_DEPTH, } from './mongo-sanitize.js';
 export { proposable, ASK_PROVENANCE_REFUSED_COUNTER, } from './ask-provenance.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';
+export { tagRouteGate, getRouteGates, audited, dynamicAuthz, buildRouteTable, isWriteMethod, summarizeRouteTable, DYNAMIC_PRINCIPALS, type DynamicPrincipal, type RouteTableEntry, } from './route-table.js';
+export { armDeferredQuotaCheck, runDeferredQuotaCheck, } from './deferred-quota-check.js';
+export { ON_BEHALF_HEADER, ON_BEHALF_CALLERS, onBehalfHeaders, onBehalfCaller, type OnBehalfSubject, } from './on-behalf.js';
+export { QUOTA_EXEMPT_ROUTES, isQuotaExemptRoute, type QuotaExemptRoute, } from './quota-exempt-routes.js';

package/lib/middleware/index.js

@@ -7,9 +7,12 @@ export { requireAssurance, refuseWeakSession, refuseForOrgAdminAssurance, requir
 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 { requireSystemOrg, requireSystemOrgPermission } from './ecosystem-guard.js';
 export { mongoSanitize, MAX_SANITIZE_DEPTH, } from './mongo-sanitize.js';
 export { proposable, ASK_PROVENANCE_REFUSED_COUNTER, } from './ask-provenance.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,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
+export { tagRouteGate, getRouteGates, audited, dynamicAuthz, buildRouteTable, isWriteMethod, summarizeRouteTable, DYNAMIC_PRINCIPALS, } from './route-table.js';
+export { armDeferredQuotaCheck, runDeferredQuotaCheck, } from './deferred-quota-check.js';
+export { ON_BEHALF_HEADER, ON_BEHALF_CALLERS, onBehalfHeaders, onBehalfCaller, } from './on-behalf.js';
+export { QUOTA_EXEMPT_ROUTES, isQuotaExemptRoute, } from './quota-exempt-routes.js';
+//# sourceMappingURL=data:application/json;base64,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

package/lib/middleware/on-behalf.d.ts

@@ -0,0 +1,37 @@
+import type { Request } from 'express';
+/** The header carrying the signed on-behalf marker (lower-case, as Node reads it). */
+export declare const ON_BEHALF_HEADER = "x-pb-on-behalf";
+/**
+ * Services whose on-behalf marker is honoured: the ones that forward a user's
+ * token as a matter of design. A marker signed by any other service — valid
+ * signature or not — is ignored, so a compromised peer that never forwards user
+ * tokens cannot start waiving its tenants' meters.
+ */
+export declare const ON_BEHALF_CALLERS: readonly string[];
+/** Who a marker vouches for. Defaults to the ambient request's verified principal. */
+export interface OnBehalfSubject {
+    /** The user (`sub`) whose token rides the same request. */
+    sub: string;
+    /** Their active org. */
+    organizationId: string;
+}
+/**
+ * Headers to add beside a forwarded user `Authorization` so the peer does not
+ * bill the hop a second time. Mint per call (the marker expires in 120 s).
+ *
+ * The subject defaults to the ambient audit context's VERIFIED principal (the
+ * inbound request this call serves). Returns `{}` — the hop is billed normally,
+ * the safe direction — when there is no user principal to vouch for, or when
+ * this process cannot sign (no service key).
+ */
+export declare function onBehalfHeaders(subject?: OnBehalfSubject): Record<string, string>;
+/**
+ * The internal service that vouched for this request with a VALID on-behalf
+ * marker, else `undefined`. Requires the request to be authenticated (`req.user`
+ * set by requireAuth) — the marker is only meaningful against a verified user.
+ *
+ * Every rejection of a PRESENT header is counted on
+ * `quota_on_behalf_rejected_total{reason}`: a forged header from a user lands
+ * there as `invalid` (no service key signs it), and the request is billed.
+ */
+export declare function onBehalfCaller(req: Request): string | undefined;

package/lib/middleware/on-behalf.js

@@ -0,0 +1,143 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * ON-BEHALF calls: a service forwarding the end user's own bearer token to a
+ * peer, as part of a request that was ALREADY metered where it arrived.
+ *
+ * The ask agent acts strictly as the calling user — its tools forward the
+ * user's token so the peer's tenancy, permission and compliance gates apply as
+ * if the user had called them — and pipeline's confirm-placeholder-plugins does
+ * the same against the plugin service. Each of those hops is a USER request to
+ * the peer, so the peer's `apiCalls` meter billed it: one agent turn was 10-20
+ * apiCalls on top of the turn itself (which is metered, and AI-reserved).
+ *
+ * The marker that waives that second charge has to be something the USER CANNOT
+ * PRODUCE, or any member could stop paying for API calls by setting a header.
+ * So it is a SIGNED SERVICE TOKEN (the calling service's own ES256 key, the same
+ * key material `requireAuth` trusts for service principals), carried in
+ * {@link ON_BEHALF_HEADER} beside the user's untouched `Authorization`:
+ *
+ *  - `type: 'on_behalf'` — never `access`, so the marker is useless as a bearer
+ *    token anywhere (`requireAuth` and `verifyServicePrincipal` both demand
+ *    `type: 'access'`);
+ *  - `obo` + `organizationId` — BOUND to the user and org it vouches for, and
+ *    honoured only when both equal the request's verified `req.user`;
+ *  - the signer must be on {@link ON_BEHALF_CALLERS} — a service that forwards
+ *    user tokens by design — and not on the service-token denylist;
+ *  - 120 s TTL, minted per outbound call.
+ *
+ * What a valid marker changes is narrow: the apiCalls/automationCalls METER and
+ * CHECK skip the request (`callQuotaExemption`). Tenancy, permissions, audit and
+ * every reservation-gated quota (aiCalls, pipelines, plugins) apply exactly as
+ * before — an on-behalf `/generate` still reserves its own aiCalls slot.
+ */
+import { randomUUID } from 'crypto';
+import { issuerAudienceOptions } from './jwt-verify.js';
+import { isServiceTokenDenied, serviceNameOf } from './service-tokens.js';
+import { currentAuditContext } from '../services/audit-context.js';
+import { isServiceKid, signServiceJwt, verifyServiceJwt } from '../services/service-keys.js';
+import { decodeJwtHeader } from '../utils/jwk.js';
+import { createLogger } from '../utils/logger.js';
+import { emitCounter } from '../utils/metric-emitter.js';
+const logger = createLogger('on-behalf');
+/** The header carrying the signed on-behalf marker (lower-case, as Node reads it). */
+export const ON_BEHALF_HEADER = 'x-pb-on-behalf';
+/**
+ * Services whose on-behalf marker is honoured: the ones that forward a user's
+ * token as a matter of design. A marker signed by any other service — valid
+ * signature or not — is ignored, so a compromised peer that never forwards user
+ * tokens cannot start waiving its tenants' meters.
+ */
+export const ON_BEHALF_CALLERS = ['ask', 'pipeline'];
+/** Marker lifetime. Minted per outbound call, so it only has to outlive one hop. */
+const ON_BEHALF_TTL_SECONDS = 120;
+/** The `type` claim that makes the marker unusable as an access token. */
+const ON_BEHALF_TOKEN_TYPE = 'on_behalf';
+/**
+ * Headers to add beside a forwarded user `Authorization` so the peer does not
+ * bill the hop a second time. Mint per call (the marker expires in 120 s).
+ *
+ * The subject defaults to the ambient audit context's VERIFIED principal (the
+ * inbound request this call serves). Returns `{}` — the hop is billed normally,
+ * the safe direction — when there is no user principal to vouch for, or when
+ * this process cannot sign (no service key).
+ */
+export function onBehalfHeaders(subject) {
+    const principal = subject ?? ambientSubject();
+    if (!principal)
+        return {};
+    try {
+        const token = signServiceJwt({
+            type: ON_BEHALF_TOKEN_TYPE,
+            principalType: 'service',
+            obo: principal.sub,
+            organizationId: principal.organizationId,
+            jti: randomUUID(),
+        }, { serviceName: process.env.SERVICE_NAME || 'api', expiresInSeconds: ON_BEHALF_TTL_SECONDS, ...issuerAudienceOptions() });
+        return { [ON_BEHALF_HEADER]: token };
+    }
+    catch (err) {
+        logger.debug('On-behalf marker not minted; the peer will meter the hop', { error: String(err) });
+        return {};
+    }
+}
+function ambientSubject() {
+    const user = currentAuditContext()?.principal?.();
+    if (!user || user.principalType === 'service' || !user.sub || !user.organizationId)
+        return undefined;
+    return { sub: user.sub, organizationId: user.organizationId };
+}
+/** Memo per request: the meter (on `finish`) and the check (in requireAuth) both ask. */
+const verdicts = new WeakMap();
+/**
+ * The internal service that vouched for this request with a VALID on-behalf
+ * marker, else `undefined`. Requires the request to be authenticated (`req.user`
+ * set by requireAuth) — the marker is only meaningful against a verified user.
+ *
+ * Every rejection of a PRESENT header is counted on
+ * `quota_on_behalf_rejected_total{reason}`: a forged header from a user lands
+ * there as `invalid` (no service key signs it), and the request is billed.
+ */
+export function onBehalfCaller(req) {
+    const memo = verdicts.get(req);
+    if (memo !== undefined)
+        return memo ?? undefined;
+    const verdict = verifyMarker(req);
+    verdicts.set(req, verdict);
+    return verdict ?? undefined;
+}
+function verifyMarker(req) {
+    const raw = req.headers?.[ON_BEHALF_HEADER];
+    const token = Array.isArray(raw) ? raw[0] : raw;
+    if (!token)
+        return null;
+    const reject = (reason) => {
+        emitCounter('quota_on_behalf_rejected_total', { reason });
+        return null;
+    };
+    const user = req.user;
+    if (!user?.sub || !user.organizationId)
+        return reject('unauthenticated');
+    try {
+        const header = decodeJwtHeader(token);
+        if (!header?.kid || !isServiceKid(header.kid))
+            return reject('invalid');
+        const claims = verifyServiceJwt(token, { kid: header.kid, ...issuerAudienceOptions() });
+        if (claims.type !== ON_BEHALF_TOKEN_TYPE || claims.principalType !== 'service')
+            return reject('invalid');
+        const caller = serviceNameOf(claims);
+        if (!caller || isServiceTokenDenied(claims))
+            return reject('denied');
+        if (!ON_BEHALF_CALLERS.includes(caller))
+            return reject('caller');
+        if (claims.obo !== user.sub)
+            return reject('subject');
+        if (String(claims.organizationId ?? '').toLowerCase() !== user.organizationId.toLowerCase())
+            return reject('org');
+        return caller;
+    }
+    catch {
+        return reject('invalid');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"on-behalf.js","sourceRoot":"","sources":["../../src/middleware/on-behalf.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * ON-BEHALF calls: a service forwarding the end user's own bearer token to a\n * peer, as part of a request that was ALREADY metered where it arrived.\n *\n * The ask agent acts strictly as the calling user — its tools forward the\n * user's token so the peer's tenancy, permission and compliance gates apply as\n * if the user had called them — and pipeline's confirm-placeholder-plugins does\n * the same against the plugin service. Each of those hops is a USER request to\n * the peer, so the peer's `apiCalls` meter billed it: one agent turn was 10-20\n * apiCalls on top of the turn itself (which is metered, and AI-reserved).\n *\n * The marker that waives that second charge has to be something the USER CANNOT\n * PRODUCE, or any member could stop paying for API calls by setting a header.\n * So it is a SIGNED SERVICE TOKEN (the calling service's own ES256 key, the same\n * key material `requireAuth` trusts for service principals), carried in\n * {@link ON_BEHALF_HEADER} beside the user's untouched `Authorization`:\n *\n *  - `type: 'on_behalf'` — never `access`, so the marker is useless as a bearer\n *    token anywhere (`requireAuth` and `verifyServicePrincipal` both demand\n *    `type: 'access'`);\n *  - `obo` + `organizationId` — BOUND to the user and org it vouches for, and\n *    honoured only when both equal the request's verified `req.user`;\n *  - the signer must be on {@link ON_BEHALF_CALLERS} — a service that forwards\n *    user tokens by design — and not on the service-token denylist;\n *  - 120 s TTL, minted per outbound call.\n *\n * What a valid marker changes is narrow: the apiCalls/automationCalls METER and\n * CHECK skip the request (`callQuotaExemption`). Tenancy, permissions, audit and\n * every reservation-gated quota (aiCalls, pipelines, plugins) apply exactly as\n * before — an on-behalf `/generate` still reserves its own aiCalls slot.\n */\n\nimport { randomUUID } from 'crypto';\nimport type { Request } from 'express';\nimport { issuerAudienceOptions } from './jwt-verify.js';\nimport { isServiceTokenDenied, serviceNameOf } from './service-tokens.js';\nimport { currentAuditContext } from '../services/audit-context.js';\nimport { isServiceKid, signServiceJwt, verifyServiceJwt } from '../services/service-keys.js';\nimport { decodeJwtHeader } from '../utils/jwk.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('on-behalf');\n\n/** The header carrying the signed on-behalf marker (lower-case, as Node reads it). */\nexport const ON_BEHALF_HEADER = 'x-pb-on-behalf';\n\n/**\n * Services whose on-behalf marker is honoured: the ones that forward a user's\n * token as a matter of design. A marker signed by any other service — valid\n * signature or not — is ignored, so a compromised peer that never forwards user\n * tokens cannot start waiving its tenants' meters.\n */\nexport const ON_BEHALF_CALLERS: readonly string[] = ['ask', 'pipeline'];\n\n/** Marker lifetime. Minted per outbound call, so it only has to outlive one hop. */\nconst ON_BEHALF_TTL_SECONDS = 120;\n\n/** The `type` claim that makes the marker unusable as an access token. */\nconst ON_BEHALF_TOKEN_TYPE = 'on_behalf';\n\n/** Who a marker vouches for. Defaults to the ambient request's verified principal. */\nexport interface OnBehalfSubject {\n  /** The user (`sub`) whose token rides the same request. */\n  sub: string;\n  /** Their active org. */\n  organizationId: string;\n}\n\n/**\n * Headers to add beside a forwarded user `Authorization` so the peer does not\n * bill the hop a second time. Mint per call (the marker expires in 120 s).\n *\n * The subject defaults to the ambient audit context's VERIFIED principal (the\n * inbound request this call serves). Returns `{}` — the hop is billed normally,\n * the safe direction — when there is no user principal to vouch for, or when\n * this process cannot sign (no service key).\n */\nexport function onBehalfHeaders(subject?: OnBehalfSubject): Record<string, string> {\n  const principal = subject ?? ambientSubject();\n  if (!principal) return {};\n  try {\n    const token = signServiceJwt(\n      {\n        type: ON_BEHALF_TOKEN_TYPE,\n        principalType: 'service',\n        obo: principal.sub,\n        organizationId: principal.organizationId,\n        jti: randomUUID(),\n      },\n      { serviceName: process.env.SERVICE_NAME || 'api', expiresInSeconds: ON_BEHALF_TTL_SECONDS, ...issuerAudienceOptions() },\n    );\n    return { [ON_BEHALF_HEADER]: token };\n  } catch (err) {\n    logger.debug('On-behalf marker not minted; the peer will meter the hop', { error: String(err) });\n    return {};\n  }\n}\n\nfunction ambientSubject(): OnBehalfSubject | undefined {\n  const user = currentAuditContext()?.principal?.();\n  if (!user || user.principalType === 'service' || !user.sub || !user.organizationId) return undefined;\n  return { sub: user.sub, organizationId: user.organizationId };\n}\n\n/** Memo per request: the meter (on `finish`) and the check (in requireAuth) both ask. */\nconst verdicts = new WeakMap<Request, string | null>();\n\n/**\n * The internal service that vouched for this request with a VALID on-behalf\n * marker, else `undefined`. Requires the request to be authenticated (`req.user`\n * set by requireAuth) — the marker is only meaningful against a verified user.\n *\n * Every rejection of a PRESENT header is counted on\n * `quota_on_behalf_rejected_total{reason}`: a forged header from a user lands\n * there as `invalid` (no service key signs it), and the request is billed.\n */\nexport function onBehalfCaller(req: Request): string | undefined {\n  const memo = verdicts.get(req);\n  if (memo !== undefined) return memo ?? undefined;\n  const verdict = verifyMarker(req);\n  verdicts.set(req, verdict);\n  return verdict ?? undefined;\n}\n\nfunction verifyMarker(req: Request): string | null {\n  const raw = req.headers?.[ON_BEHALF_HEADER];\n  const token = Array.isArray(raw) ? raw[0] : raw;\n  if (!token) return null;\n  const reject = (reason: string): null => {\n    emitCounter('quota_on_behalf_rejected_total', { reason });\n    return null;\n  };\n  const user = req.user;\n  if (!user?.sub || !user.organizationId) return reject('unauthenticated');\n  try {\n    const header = decodeJwtHeader(token);\n    if (!header?.kid || !isServiceKid(header.kid)) return reject('invalid');\n    const claims = verifyServiceJwt<{ type?: string; principalType?: string; sub?: string; obo?: string; organizationId?: string }>(\n      token, { kid: header.kid, ...issuerAudienceOptions() },\n    );\n    if (claims.type !== ON_BEHALF_TOKEN_TYPE || claims.principalType !== 'service') return reject('invalid');\n    const caller = serviceNameOf(claims);\n    if (!caller || isServiceTokenDenied(claims)) return reject('denied');\n    if (!ON_BEHALF_CALLERS.includes(caller)) return reject('caller');\n    if (claims.obo !== user.sub) return reject('subject');\n    if (String(claims.organizationId ?? '').toLowerCase() !== user.organizationId.toLowerCase()) return reject('org');\n    return caller;\n  } catch {\n    return reject('invalid');\n  }\n}\n"]}

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

@@ -3,6 +3,7 @@
  * `authz.denied` audit sink they report refusals to.
  */
 import type { Request, Response, NextFunction } from 'express';
+import { type AuditAuthBlock } from '../services/audit-context.js';
 import { type Permission } from '../types/permissions.js';
 /**
  * Whether the request's user holds `permission`. Superadmins implicitly hold
@@ -26,6 +27,16 @@ export interface AuthzDenialInfo {
     path: string;
     /** What was required: the missing permission(s), or 'system-admin'. */
     required: string;
+    /** Client ip (`req.ip`, proxy-resolved). */
+    ip?: string;
+    /** Sanitized, length-capped User-Agent. */
+    userAgent?: string;
+    /** The request's correlation id (the ambient audit context's, else a valid `X-Request-Id`). */
+    requestId?: string;
+    /** The real sysadmin behind an impersonation token, from the verified token. */
+    impersonatorId?: string;
+    /** The credential that was refused (key id, session, scope, …) — the `_auth` block. */
+    auth?: AuditAuthBlock;
 }
 /**
  * Register (or clear, with `undefined`) the process-wide authorization-denial

package/lib/middleware/permission-gates.js

@@ -3,6 +3,7 @@
 import { tagRouteGate } from './route-table.js';
 import { isServicePrincipal, serviceNameOf } from './service-tokens.js';
 import { HttpStatus } from '../constants/http-status.js';
+import { auditAuthBlock, currentAuditContext, sanitizeCorrelationId, sanitizeUserAgent } from '../services/audit-context.js';
 import { serviceIdentity } from '../services/service-keys.js';
 import { ErrorCode } from '../types/error-codes.js';
 import { hasPermission } from '../types/permissions.js';
@@ -60,6 +61,11 @@ export function recordAuthzDenial(req, required) {
             // query param, and this path is persisted verbatim into the audit log.
             path: (req.originalUrl || req.url).split('?')[0],
             required,
+            ip: req.ip,
+            userAgent: sanitizeUserAgent(req.headers?.['user-agent']),
+            requestId: currentAuditContext()?.requestId ?? sanitizeCorrelationId(req.headers?.['x-request-id']),
+            impersonatorId: req.user?.impersonatorId,
+            auth: auditAuthBlock(req.user),
         });
     }
     catch {
@@ -257,4 +263,4 @@ export function requireFeature(feature) {
         next();
     }, { kind: 'feature', feature });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permission-gates.js","sourceRoot":"","sources":["../../src/middleware/permission-gates.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Authorization gates — permissions, system admin, features — and the\n * `authz.denied` audit sink they report refusals to.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport { tagRouteGate } from './route-table.js';\nimport { isServicePrincipal, serviceNameOf } from './service-tokens.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport { serviceIdentity } from '../services/service-keys.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { type Permission, hasPermission } from '../types/permissions.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('auth-middleware');\n/**\n * Whether the request's user holds `permission`. Superadmins implicitly hold\n * every permission. Reads the resolved `permissions` claim (set at token issue,\n * or re-derived per request by the platform).\n */\nexport function userHasPermission(req: Request, permission: Permission): boolean {\n  return hasPermission(req.user?.permissions, permission, req.user?.isSuperAdmin);\n}\n\n/**\n * Context passed to a registered authorization-denial auditor when a\n * state-changing request is rejected by `requirePermission` /\n * `requireSystemAdmin`.\n */\nexport interface AuthzDenialInfo {\n  /** The denied user's id (`sub`), if authenticated. */\n  actorId?: string;\n  actorEmail?: string;\n  /** The user's active org at denial time. */\n  orgId?: string;\n  /** HTTP method + path of the rejected request. */\n  method: string;\n  path: string;\n  /** What was required: the missing permission(s), or 'system-admin'. */\n  required: string;\n}\n\n/**\n * Optional sink for denied-authorization events. Left unset by default so\n * api-core stays decoupled from any audit transport — a service registers one\n * at boot (typically forwarding to its `RemoteAuditClient` as an\n * `authz.denied` event, or, on platform, to the local `audit()` helper).\n * MUST be best-effort: it is invoked inside the request path, so it must never\n * throw or block (the gate wraps the call in try/catch regardless).\n */\nlet authzDenialAuditor: ((info: AuthzDenialInfo) => void) | undefined;\n\n/**\n * Register (or clear, with `undefined`) the process-wide authorization-denial\n * auditor. Idempotent; the last registration wins.\n */\nexport function setAuthzDenialAuditor(fn: ((info: AuthzDenialInfo) => void) | undefined): void {\n  authzDenialAuditor = fn;\n}\n\n/**\n * Emit a denial event, best-effort. Only fires for state-changing (non-GET,\n * non-HEAD/OPTIONS) requests — a rejected GET is low-signal probing noise and\n * would amplify audit volume under a scan. Never throws.\n *\n * The permission gates here call it themselves. Export it for data-driven checks\n * a route makes inline (cross-org access, service-only endpoints), so those 403s\n * reach the same `authz.denied` trail. `required` names what was missing.\n */\nexport function recordAuthzDenial(req: Request, required: string): void {\n  const auditor = authzDenialAuditor;\n  if (!auditor) return;\n  const method = req.method.toUpperCase();\n  if (method === 'GET' || method === 'HEAD' || method === 'OPTIONS') return;\n  try {\n    auditor({\n      actorId: req.user?.sub,\n      actorEmail: req.user?.email,\n      orgId: req.user?.organizationId,\n      method,\n      // Strip the query string — a denied request may carry a token/secret as a\n      // query param, and this path is persisted verbatim into the audit log.\n      path: (req.originalUrl || req.url).split('?')[0],\n      required,\n    });\n  } catch {\n    // Best-effort — a broken auditor must never break the auth gate.\n  }\n}\n\n/** The shared gate preamble: answer 401 and return false when unauthenticated. */\nfunction requireUser(req: Request, res: Response): req is Request & { user: NonNullable<Request['user']> } {\n  if (req.user) return true;\n  sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n  return false;\n}\n\n/** Audit + answer a permission refusal (`missing` defaults to every required permission). */\nfunction denyPermission(req: Request, res: Response, permissions: Permission[], mode: 'or' | 'and', missing: Permission[] = permissions): void {\n  recordAuthzDenial(req, permissions.join(` ${mode} `));\n  sendError(\n    res, HttpStatus.FORBIDDEN,\n    `Missing required permission: ${missing.join(` ${mode} `)}`,\n    ErrorCode.INSUFFICIENT_PERMISSIONS,\n  );\n}\n\n/**\n * Requires that the user hold AT LEAST ONE of the given permissions (or be a\n * superadmin). Use after requireAuth. Mirrors `requireRole`'s any-of semantics;\n * pass a single permission for a specific action, or several when any one of\n * them should grant access.\n */\nexport function requirePermission(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!requireUser(req, res)) return;\n    // userHasPermission → hasPermission already grants superadmins every\n    // permission, so this single check covers both the superadmin bypass and\n    // the any-of membership test without re-inlining either.\n    if (permissions.some((p) => userHasPermission(req, p))) return next();\n    denyPermission(req, res, permissions, 'or');\n  }, { kind: 'permission', mode: 'any', permissions });\n}\n\n/**\n * Requires that the user hold EVERY one of the given permissions (or be a\n * superadmin) — the AND counterpart to `requirePermission`'s any-of. Use for a\n * sensitive action that legitimately demands two distinct capabilities at once\n * (e.g. a cross-surface operation), so the guarantee is explicit rather than\n * approximated by chaining two `requirePermission` gates. Superadmins bypass\n * (they implicitly hold every permission).\n */\nexport function requireAllPermissions(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!requireUser(req, res)) return;\n    const missing = permissions.filter((p) => !userHasPermission(req, p));\n    if (missing.length === 0) return next();\n    denyPermission(req, res, permissions, 'and', missing);\n  }, { kind: 'permission', mode: 'all', permissions });\n}\n\n/**\n * Like {@link requirePermission} (any-of) but ALSO admits an internal service\n * principal (`principalType: 'service'`). For READ endpoints that BOTH\n * interactive users — who must hold one of the `:read` capabilities — AND\n * service-to-service callers legitimately hit; service tokens carry no\n * permission claims (they're least-privilege `role:member`), so a plain\n * `requirePermission` would wrongly 403 them. Superadmins pass via\n * `userHasPermission`'s implicit-all. Use only where a service caller is a known,\n * intended consumer of the route (verify the callers); prefer plain\n * `requirePermission` for purely user-facing reads.\n */\nexport function requirePermissionOrService(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!requireUser(req, res)) return;\n    if (isServicePrincipal(req) || permissions.some((p) => userHasPermission(req, p))) return next();\n    denyPermission(req, res, permissions, 'or');\n  }, { kind: 'permission', mode: 'any', permissions, allowService: true });\n}\n\n/**\n * Gate an endpoint to internal service-to-service callers only (a\n * `principalType: 'service'` principal minted via {@link signServiceToken} / `getServiceAuthHeader`).\n * Rejects any user token. For NON-user-facing endpoints — entity-event ingest,\n * auto-subscribe, and similar peer-service hooks — that a browser must never\n * reach. Compose after `requireAuth` so `req.user` is populated.\n */\nexport function requireServicePrincipal(req: Request, res: Response, next: NextFunction): void {\n  if (!isServicePrincipal(req)) {\n    // 403 (not 400) — this is an authorization refusal; status must match the\n    // INSUFFICIENT_PERMISSIONS code and the sibling gates (requirePermission, etc.).\n    return sendError(res, HttpStatus.FORBIDDEN, 'Internal service calls only', ErrorCode.INSUFFICIENT_PERMISSIONS);\n  }\n  next();\n}\ntagRouteGate(requireServicePrincipal, { kind: 'servicePrincipal' });\n\n/**\n * THE gate for an INTERNAL route — the one every `/internal/*` path, the\n * quota usage counters, the entity-event ingest and the audit ingest go through.\n *\n * Two rules, both fail-closed:\n *\n *  1. **No user token, ever.** Not a member's, not a superadmin's, not a\n *     service-account key's. An internal route is a peer-service API surface, so\n *     \"a sufficiently privileged human\" is not an acceptable caller — that\n *     equivalence is exactly how a browser-reachable path becomes a tenant\n *     boundary bug. `requireServicePrincipal` already refused users; this also\n *     closes the `|| isSystemAdmin(req)` escape hatches that had grown around\n *     the individual internal routes.\n *  2. **Only the NAMED callers.** `callers` lists the services that legitimately\n *     call this route, and the name is cryptographically bound to the signing\n *     key (`services/service-keys.ts`), so this is an identity check rather than\n *     a claim check. It is the same allow-list the mesh policy names, at the\n *     layer that also holds in docker compose, where there is no mesh at all —\n *     the Istio `AuthorizationPolicy` is defence in depth on top, never the\n *     enforcement.\n *\n * Compose after `requireAuth` so `req.user` is populated. Refusals are counted\n * (`internal_route_refused_total`) and audited through the shared `authz.denied`\n * sink.\n */\nexport function requireInternalService(options: { callers: readonly string[] }) {\n  const allowed = new Set(options.callers);\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    const refuse = (reason: 'unauthenticated' | 'user_token' | 'wrong_caller'): void => {\n      emitCounter('internal_route_refused_total', {\n        service: serviceIdentity(),\n        route: req.route?.path ? `${req.method} ${req.baseUrl}${req.route.path}` : `${req.method} ${(req.originalUrl || req.url).split('?')[0]}`,\n        reason,\n        caller: serviceNameOf(req.user) ?? 'none',\n      });\n      recordAuthzDenial(req, `internal-service (${options.callers.join(', ')})`);\n      if (reason === 'unauthenticated') {\n        return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n      }\n      logger.warn('Refused an internal route', { reason, path: (req.originalUrl || req.url).split('?')[0], caller: serviceNameOf(req.user) });\n      return sendError(res, HttpStatus.FORBIDDEN, 'Internal service calls only', ErrorCode.INSUFFICIENT_PERMISSIONS);\n    };\n\n    if (!req.user) return refuse('unauthenticated');\n    if (!isServicePrincipal(req)) return refuse('user_token');\n    const caller = serviceNameOf(req.user);\n    if (!caller || !allowed.has(caller)) return refuse('wrong_caller');\n    next();\n  }, { kind: 'servicePrincipal' }, { kind: 'internalService', callers: [...options.callers] });\n}\n\n/**\n * Check if the request is from a system admin.\n *\n * Authority is granted solely by the user-level `isSuperAdmin` flag carried\n * in the JWT — never by membership in the well-known 'system' org, which would\n * conflate a Pipeline Builder operator with a customer tenant and let any\n * write that created a 'system'-named org quietly grant cross-org authority. The `system` org still exists as a *content holder* for shared\n * sample data; it confers no privilege.\n */\nexport function isSystemAdmin(req: Request): boolean {\n  return req.user?.isSuperAdmin === true;\n}\n\n/**\n * Whether the request's token carries a specific capability `scope` (e.g.\n * `'reporting:ingest'`). Used to gate endpoints that accept a narrow machine\n * identity — a normal interactive user token has no `scope` and returns false.\n */\nexport function hasScope(req: Request, scope: string): boolean {\n  return req.user?.scope === scope;\n}\n\n/** Requires a system admin — granted solely by the `isSuperAdmin` token claim.\n *  Use after requireAuth. */\nexport function requireSystemAdmin(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  if (!isSystemAdmin(req)) {\n    recordAuthzDenial(req, 'system-admin');\n    return sendError(\n      res, HttpStatus.FORBIDDEN,\n      'Access denied. Only system administrators can perform this action.',\n      ErrorCode.INSUFFICIENT_PERMISSIONS,\n    );\n  }\n  next();\n}\ntagRouteGate(requireSystemAdmin, { kind: 'systemAdmin' });\n\n/**\n * Require a specific feature flag. Use after requireAuth.\n * Checks the `features` array in the JWT payload (set at token issuance).\n * Sysadmins (isSuperAdmin) bypass — they always have every feature.\n */\nexport function requireFeature(feature: string) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!requireUser(req, res)) return;\n\n    // Sysadmins get all features; the `features` array on their token is\n    // populated with every flag at issuance time but the bypass here keeps\n    // the rule explicit and survives a token issued before a new feature\n    // flag was added.\n    if (req.user.isSuperAdmin === true) return next();\n\n    if (!req.user.features?.includes(feature)) {\n      // Route feature-gate denials through the same audit sink as\n      // requirePermission / requireSystemAdmin so a probe for an\n      // unentitled capability leaves a trail (state-changing methods only).\n      recordAuthzDenial(req, `feature:${feature}`);\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        `This feature requires a higher plan (${feature})`,\n        ErrorCode.INSUFFICIENT_PERMISSIONS,\n      );\n    }\n\n    next();\n  }, { kind: 'feature', feature });\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permission-gates.js","sourceRoot":"","sources":["../../src/middleware/permission-gates.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAQtC,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,iBAAiB,EAAuB,MAAM,8BAA8B,CAAC;AAClJ,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAmB,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,MAAM,MAAM,GAAG,YAAY,CAAC,iBAAiB,CAAC,CAAC;AAC/C;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAY,EAAE,UAAsB;IACpE,OAAO,aAAa,CAAC,GAAG,CAAC,IAAI,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;AAClF,CAAC;AA8BD;;;;;;;GAOG;AACH,IAAI,kBAAiE,CAAC;AAEtE;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CAAC,EAAiD;IACrF,kBAAkB,GAAG,EAAE,CAAC;AAC1B,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAY,EAAE,QAAgB;IAC9D,MAAM,OAAO,GAAG,kBAAkB,CAAC;IACnC,IAAI,CAAC,OAAO;QAAE,OAAO;IACrB,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;IACxC,IAAI,MAAM,KAAK,KAAK,IAAI,MAAM,KAAK,MAAM,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO;IAC1E,IAAI,CAAC;QACH,OAAO,CAAC;YACN,OAAO,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG;YACtB,UAAU,EAAE,GAAG,CAAC,IAAI,EAAE,KAAK;YAC3B,KAAK,EAAE,GAAG,CAAC,IAAI,EAAE,cAAc;YAC/B,MAAM;YACN,0EAA0E;YAC1E,uEAAuE;YACvE,IAAI,EAAE,CAAC,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAChD,QAAQ;YACR,EAAE,EAAE,GAAG,CAAC,EAAE;YACV,SAAS,EAAE,iBAAiB,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,YAAY,CAAC,CAAC;YACzD,SAAS,EAAE,mBAAmB,EAAE,EAAE,SAAS,IAAI,qBAAqB,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,cAAc,CAAC,CAAC;YACnG,cAAc,EAAE,GAAG,CAAC,IAAI,EAAE,cAAc;YACxC,IAAI,EAAE,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC;SAC/B,CAAC,CAAC;IACL,CAAC;IAAC,MAAM,CAAC;QACP,iEAAiE;IACnE,CAAC;AACH,CAAC;AAED,kFAAkF;AAClF,SAAS,WAAW,CAAC,GAAY,EAAE,GAAa;IAC9C,IAAI,GAAG,CAAC,IAAI;QAAE,OAAO,IAAI,CAAC;IAC1B,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,yBAAyB,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;IAC3F,OAAO,KAAK,CAAC;AACf,CAAC;AAED,6FAA6F;AAC7F,SAAS,cAAc,CAAC,GAAY,EAAE,GAAa,EAAE,WAAyB,EAAE,IAAkB,EAAE,OAAO,GAAiB,WAAW;IACrI,iBAAiB,CAAC,GAAG,EAAE,WAAW,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC;IACtD,SAAS,CACP,GAAG,EAAE,UAAU,CAAC,SAAS,EACzB,gCAAgC,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,CAAC,EAAE,EAC3D,SAAS,CAAC,wBAAwB,CACnC,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAG,WAAyB;IAC5D,OAAO,YAAY,CAAC,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB,EAAQ,EAAE;QAC5E,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC;YAAE,OAAO;QACnC,qEAAqE;QACrE,yEAAyE;QACzE,yDAAyD;QACzD,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;YAAE,OAAO,IAAI,EAAE,CAAC;QACtE,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC;IAC9C,CAAC,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,qBAAqB,CAAC,GAAG,WAAyB;IAChE,OAAO,YAAY,CAAC,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB,EAAQ,EAAE;QAC5E,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC;YAAE,OAAO;QACnC,MAAM,OAAO,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,iBAAiB,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QACtE,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,EAAE,CAAC;QACxC,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IACxD,CAAC,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,0BAA0B,CAAC,GAAG,WAAyB;IACrE,OAAO,YAAY,CAAC,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB,EAAQ,EAAE;QAC5E,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC;YAAE,OAAO;QACnC,IAAI,kBAAkB,CAAC,GAAG,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;YAAE,OAAO,IAAI,EAAE,CAAC;QACjG,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC;IAC9C,CAAC,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC;AAC3E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB;IACrF,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,EAAE,CAAC;QAC7B,0EAA0E;QAC1E,iFAAiF;QACjF,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,SAAS,EAAE,6BAA6B,EAAE,SAAS,CAAC,wBAAwB,CAAC,CAAC;IACjH,CAAC;IACD,IAAI,EAAE,CAAC;AACT,CAAC;AACD,YAAY,CAAC,uBAAuB,EAAE,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,sBAAsB,CAAC,OAAuC;IAC5E,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACzC,OAAO,YAAY,CAAC,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB,EAAQ,EAAE;QAC5E,MAAM,MAAM,GAAG,CAAC,MAAyD,EAAQ,EAAE;YACjF,WAAW,CAAC,8BAA8B,EAAE;gBAC1C,OAAO,EAAE,eAAe,EAAE;gBAC1B,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,OAAO,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE;gBACxI,MAAM;gBACN,MAAM,EAAE,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,MAAM;aAC1C,CAAC,CAAC;YACH,iBAAiB,CAAC,GAAG,EAAE,qBAAqB,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC3E,IAAI,MAAM,KAAK,iBAAiB,EAAE,CAAC;gBACjC,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,YAAY,EAAE,yBAAyB,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;YACpG,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,2BAA2B,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACxI,OAAO,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,SAAS,EAAE,6BAA6B,EAAE,SAAS,CAAC,wBAAwB,CAAC,CAAC;QACjH,CAAC,CAAC;QAEF,IAAI,CAAC,GAAG,CAAC,IAAI;YAAE,OAAO,MAAM,CAAC,iBAAiB,CAAC,CAAC;QAChD,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC;YAAE,OAAO,MAAM,CAAC,YAAY,CAAC,CAAC;QAC1D,MAAM,MAAM,GAAG,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACvC,IAAI,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC;YAAE,OAAO,MAAM,CAAC,cAAc,CAAC,CAAC;QACnE,IAAI,EAAE,CAAC;IACT,CAAC,EAAE,EAAE,IAAI,EAAE,kBAAkB,EAAE,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;AAC/F,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,aAAa,CAAC,GAAY;IACxC,OAAO,GAAG,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;AACzC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CAAC,GAAY,EAAE,KAAa;IAClD,OAAO,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,KAAK,CAAC;AACnC,CAAC;AAED;6BAC6B;AAC7B,MAAM,UAAU,kBAAkB,CAChC,GAAY,EACZ,GAAa,EACb,IAAkB;IAElB,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC;QACxB,iBAAiB,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC;QACvC,OAAO,SAAS,CACd,GAAG,EAAE,UAAU,CAAC,SAAS,EACzB,oEAAoE,EACpE,SAAS,CAAC,wBAAwB,CACnC,CAAC;IACJ,CAAC;IACD,IAAI,EAAE,CAAC;AACT,CAAC;AACD,YAAY,CAAC,kBAAkB,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC,CAAC;AAE1D;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,OAAe;IAC5C,OAAO,YAAY,CAAC,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB,EAAQ,EAAE;QAC5E,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC;YAAE,OAAO;QAEnC,qEAAqE;QACrE,uEAAuE;QACvE,qEAAqE;QACrE,kBAAkB;QAClB,IAAI,GAAG,CAAC,IAAI,CAAC,YAAY,KAAK,IAAI;YAAE,OAAO,IAAI,EAAE,CAAC;QAElD,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC1C,4DAA4D;YAC5D,2DAA2D;YAC3D,sEAAsE;YACtE,iBAAiB,CAAC,GAAG,EAAE,WAAW,OAAO,EAAE,CAAC,CAAC;YAC7C,OAAO,SAAS,CACd,GAAG,EAAE,UAAU,CAAC,SAAS,EACzB,wCAAwC,OAAO,GAAG,EAClD,SAAS,CAAC,wBAAwB,CACnC,CAAC;QACJ,CAAC;QAED,IAAI,EAAE,CAAC;IACT,CAAC,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,CAAC;AACnC,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Authorization gates — permissions, system admin, features — and the\n * `authz.denied` audit sink they report refusals to.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport { tagRouteGate } from './route-table.js';\nimport { isServicePrincipal, serviceNameOf } from './service-tokens.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport { auditAuthBlock, currentAuditContext, sanitizeCorrelationId, sanitizeUserAgent, type AuditAuthBlock } from '../services/audit-context.js';\nimport { serviceIdentity } from '../services/service-keys.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { type Permission, hasPermission } from '../types/permissions.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('auth-middleware');\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  /** Client ip (`req.ip`, proxy-resolved). */\n  ip?: string;\n  /** Sanitized, length-capped User-Agent. */\n  userAgent?: string;\n  /** The request's correlation id (the ambient audit context's, else a valid `X-Request-Id`). */\n  requestId?: string;\n  /** The real sysadmin behind an impersonation token, from the verified token. */\n  impersonatorId?: string;\n  /** The credential that was refused (key id, session, scope, …) — the `_auth` block. */\n  auth?: AuditAuthBlock;\n}\n\n/**\n * Optional sink for denied-authorization events. Left unset by default so\n * api-core stays decoupled from any audit transport — a service registers one\n * at boot (typically forwarding to its `RemoteAuditClient` as an\n * `authz.denied` event, or, on platform, to the local `audit()` helper).\n * MUST be best-effort: it is invoked inside the request path, so it must never\n * throw or block (the gate wraps the call in try/catch regardless).\n */\nlet authzDenialAuditor: ((info: AuthzDenialInfo) => void) | undefined;\n\n/**\n * Register (or clear, with `undefined`) the process-wide authorization-denial\n * auditor. Idempotent; the last registration wins.\n */\nexport function setAuthzDenialAuditor(fn: ((info: AuthzDenialInfo) => void) | undefined): void {\n  authzDenialAuditor = fn;\n}\n\n/**\n * Emit a denial event, best-effort. Only fires for state-changing (non-GET,\n * non-HEAD/OPTIONS) requests — a rejected GET is low-signal probing noise and\n * would amplify audit volume under a scan. Never throws.\n *\n * The permission gates here call it themselves. Export it for data-driven checks\n * a route makes inline (cross-org access, service-only endpoints), so those 403s\n * reach the same `authz.denied` trail. `required` names what was missing.\n */\nexport function recordAuthzDenial(req: Request, required: string): void {\n  const auditor = authzDenialAuditor;\n  if (!auditor) return;\n  const method = req.method.toUpperCase();\n  if (method === 'GET' || method === 'HEAD' || method === 'OPTIONS') return;\n  try {\n    auditor({\n      actorId: req.user?.sub,\n      actorEmail: req.user?.email,\n      orgId: req.user?.organizationId,\n      method,\n      // Strip the query string — a denied request may carry a token/secret as a\n      // query param, and this path is persisted verbatim into the audit log.\n      path: (req.originalUrl || req.url).split('?')[0],\n      required,\n      ip: req.ip,\n      userAgent: sanitizeUserAgent(req.headers?.['user-agent']),\n      requestId: currentAuditContext()?.requestId ?? sanitizeCorrelationId(req.headers?.['x-request-id']),\n      impersonatorId: req.user?.impersonatorId,\n      auth: auditAuthBlock(req.user),\n    });\n  } catch {\n    // Best-effort — a broken auditor must never break the auth gate.\n  }\n}\n\n/** The shared gate preamble: answer 401 and return false when unauthenticated. */\nfunction requireUser(req: Request, res: Response): req is Request & { user: NonNullable<Request['user']> } {\n  if (req.user) return true;\n  sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n  return false;\n}\n\n/** Audit + answer a permission refusal (`missing` defaults to every required permission). */\nfunction denyPermission(req: Request, res: Response, permissions: Permission[], mode: 'or' | 'and', missing: Permission[] = permissions): void {\n  recordAuthzDenial(req, permissions.join(` ${mode} `));\n  sendError(\n    res, HttpStatus.FORBIDDEN,\n    `Missing required permission: ${missing.join(` ${mode} `)}`,\n    ErrorCode.INSUFFICIENT_PERMISSIONS,\n  );\n}\n\n/**\n * Requires that the user hold AT LEAST ONE of the given permissions (or be a\n * superadmin). Use after requireAuth. Mirrors `requireRole`'s any-of semantics;\n * pass a single permission for a specific action, or several when any one of\n * them should grant access.\n */\nexport function requirePermission(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!requireUser(req, res)) return;\n    // userHasPermission → hasPermission already grants superadmins every\n    // permission, so this single check covers both the superadmin bypass and\n    // the any-of membership test without re-inlining either.\n    if (permissions.some((p) => userHasPermission(req, p))) return next();\n    denyPermission(req, res, permissions, 'or');\n  }, { kind: 'permission', mode: 'any', permissions });\n}\n\n/**\n * Requires that the user hold EVERY one of the given permissions (or be a\n * superadmin) — the AND counterpart to `requirePermission`'s any-of. Use for a\n * sensitive action that legitimately demands two distinct capabilities at once\n * (e.g. a cross-surface operation), so the guarantee is explicit rather than\n * approximated by chaining two `requirePermission` gates. Superadmins bypass\n * (they implicitly hold every permission).\n */\nexport function requireAllPermissions(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!requireUser(req, res)) return;\n    const missing = permissions.filter((p) => !userHasPermission(req, p));\n    if (missing.length === 0) return next();\n    denyPermission(req, res, permissions, 'and', missing);\n  }, { kind: 'permission', mode: 'all', permissions });\n}\n\n/**\n * Like {@link requirePermission} (any-of) but ALSO admits an internal service\n * principal (`principalType: 'service'`). For READ endpoints that BOTH\n * interactive users — who must hold one of the `:read` capabilities — AND\n * service-to-service callers legitimately hit; service tokens carry no\n * permission claims (they're least-privilege `role:member`), so a plain\n * `requirePermission` would wrongly 403 them. Superadmins pass via\n * `userHasPermission`'s implicit-all. Use only where a service caller is a known,\n * intended consumer of the route (verify the callers); prefer plain\n * `requirePermission` for purely user-facing reads.\n */\nexport function requirePermissionOrService(...permissions: Permission[]) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!requireUser(req, res)) return;\n    if (isServicePrincipal(req) || permissions.some((p) => userHasPermission(req, p))) return next();\n    denyPermission(req, res, permissions, 'or');\n  }, { kind: 'permission', mode: 'any', permissions, allowService: true });\n}\n\n/**\n * Gate an endpoint to internal service-to-service callers only (a\n * `principalType: 'service'` principal minted via {@link signServiceToken} / `getServiceAuthHeader`).\n * Rejects any user token. For NON-user-facing endpoints — entity-event ingest,\n * auto-subscribe, and similar peer-service hooks — that a browser must never\n * reach. Compose after `requireAuth` so `req.user` is populated.\n */\nexport function requireServicePrincipal(req: Request, res: Response, next: NextFunction): void {\n  if (!isServicePrincipal(req)) {\n    // 403 (not 400) — this is an authorization refusal; status must match the\n    // INSUFFICIENT_PERMISSIONS code and the sibling gates (requirePermission, etc.).\n    return sendError(res, HttpStatus.FORBIDDEN, 'Internal service calls only', ErrorCode.INSUFFICIENT_PERMISSIONS);\n  }\n  next();\n}\ntagRouteGate(requireServicePrincipal, { kind: 'servicePrincipal' });\n\n/**\n * THE gate for an INTERNAL route — the one every `/internal/*` path, the\n * quota usage counters, the entity-event ingest and the audit ingest go through.\n *\n * Two rules, both fail-closed:\n *\n *  1. **No user token, ever.** Not a member's, not a superadmin's, not a\n *     service-account key's. An internal route is a peer-service API surface, so\n *     \"a sufficiently privileged human\" is not an acceptable caller — that\n *     equivalence is exactly how a browser-reachable path becomes a tenant\n *     boundary bug. `requireServicePrincipal` already refused users; this also\n *     closes the `|| isSystemAdmin(req)` escape hatches that had grown around\n *     the individual internal routes.\n *  2. **Only the NAMED callers.** `callers` lists the services that legitimately\n *     call this route, and the name is cryptographically bound to the signing\n *     key (`services/service-keys.ts`), so this is an identity check rather than\n *     a claim check. It is the same allow-list the mesh policy names, at the\n *     layer that also holds in docker compose, where there is no mesh at all —\n *     the Istio `AuthorizationPolicy` is defence in depth on top, never the\n *     enforcement.\n *\n * Compose after `requireAuth` so `req.user` is populated. Refusals are counted\n * (`internal_route_refused_total`) and audited through the shared `authz.denied`\n * sink.\n */\nexport function requireInternalService(options: { callers: readonly string[] }) {\n  const allowed = new Set(options.callers);\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    const refuse = (reason: 'unauthenticated' | 'user_token' | 'wrong_caller'): void => {\n      emitCounter('internal_route_refused_total', {\n        service: serviceIdentity(),\n        route: req.route?.path ? `${req.method} ${req.baseUrl}${req.route.path}` : `${req.method} ${(req.originalUrl || req.url).split('?')[0]}`,\n        reason,\n        caller: serviceNameOf(req.user) ?? 'none',\n      });\n      recordAuthzDenial(req, `internal-service (${options.callers.join(', ')})`);\n      if (reason === 'unauthenticated') {\n        return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n      }\n      logger.warn('Refused an internal route', { reason, path: (req.originalUrl || req.url).split('?')[0], caller: serviceNameOf(req.user) });\n      return sendError(res, HttpStatus.FORBIDDEN, 'Internal service calls only', ErrorCode.INSUFFICIENT_PERMISSIONS);\n    };\n\n    if (!req.user) return refuse('unauthenticated');\n    if (!isServicePrincipal(req)) return refuse('user_token');\n    const caller = serviceNameOf(req.user);\n    if (!caller || !allowed.has(caller)) return refuse('wrong_caller');\n    next();\n  }, { kind: 'servicePrincipal' }, { kind: 'internalService', callers: [...options.callers] });\n}\n\n/**\n * Check if the request is from a system admin.\n *\n * Authority is granted solely by the user-level `isSuperAdmin` flag carried\n * in the JWT — never by membership in the well-known 'system' org, which would\n * conflate a Pipeline Builder operator with a customer tenant and let any\n * write that created a 'system'-named org quietly grant cross-org authority. The `system` org still exists as a *content holder* for shared\n * sample data; it confers no privilege.\n */\nexport function isSystemAdmin(req: Request): boolean {\n  return req.user?.isSuperAdmin === true;\n}\n\n/**\n * Whether the request's token carries a specific capability `scope` (e.g.\n * `'reporting:ingest'`). Used to gate endpoints that accept a narrow machine\n * identity — a normal interactive user token has no `scope` and returns false.\n */\nexport function hasScope(req: Request, scope: string): boolean {\n  return req.user?.scope === scope;\n}\n\n/** Requires a system admin — granted solely by the `isSuperAdmin` token claim.\n *  Use after requireAuth. */\nexport function requireSystemAdmin(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  if (!isSystemAdmin(req)) {\n    recordAuthzDenial(req, 'system-admin');\n    return sendError(\n      res, HttpStatus.FORBIDDEN,\n      'Access denied. Only system administrators can perform this action.',\n      ErrorCode.INSUFFICIENT_PERMISSIONS,\n    );\n  }\n  next();\n}\ntagRouteGate(requireSystemAdmin, { kind: 'systemAdmin' });\n\n/**\n * Require a specific feature flag. Use after requireAuth.\n * Checks the `features` array in the JWT payload (set at token issuance).\n * Sysadmins (isSuperAdmin) bypass — they always have every feature.\n */\nexport function requireFeature(feature: string) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!requireUser(req, res)) return;\n\n    // Sysadmins get all features; the `features` array on their token is\n    // populated with every flag at issuance time but the bypass here keeps\n    // the rule explicit and survives a token issued before a new feature\n    // flag was added.\n    if (req.user.isSuperAdmin === true) return next();\n\n    if (!req.user.features?.includes(feature)) {\n      // Route feature-gate denials through the same audit sink as\n      // requirePermission / requireSystemAdmin so a probe for an\n      // unentitled capability leaves a trail (state-changing methods only).\n      recordAuthzDenial(req, `feature:${feature}`);\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        `This feature requires a higher plan (${feature})`,\n        ErrorCode.INSUFFICIENT_PERMISSIONS,\n      );\n    }\n\n    next();\n  }, { kind: 'feature', feature });\n}\n\n"]}

package/lib/middleware/quota-exempt-routes.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The routes that never spend `apiCalls` (or `automationCalls`), fleet-wide.
+ *
+ * Every service meters and gates its authenticated user surface on `apiCalls`
+ * (`meterQuotaOnSuccess` + `checkQuota`, mounted at the app-routes level). A few
+ * reads are made BY THE CONSOLE ITSELF, on every page load or on a timer, not by
+ * a person doing something — metering them would burn an idle tab's org budget
+ * all day, and gating them would make a quota-exhausted org's console unable to
+ * render the very banner that says so. This list is that carve-out, and it is
+ * deliberately short: each entry names its caller and why it is free.
+ *
+ * ONE list, read in three places, so they cannot drift:
+ *   - `meterQuotaOnSuccess` skips a matching request (no increment);
+ *   - `checkQuota` skips a matching request (never 429s);
+ *   - `buildRouteTable` marks the route `quota.exempt`, and the quota coverage
+ *     check (api-core testing) treats it as covered.
+ *
+ * Each `path` is matched against BOTH the concrete request path
+ * (`/organization/64f…/seat-usage`) and the route-table pattern
+ * (`/organization/:id/seat-usage`), so a `:param` segment is written as
+ * `[^/]+`. Paths are service-local (nginx strips `/api`).
+ *
+ * The quota service itself is not on the list because it meters nothing: its
+ * reads (`GET /quotas`, which QuotaBanner polls every 60s) never cost a call.
+ * Documented in docs/quotas.md ("Exempt routes").
+ */
+export interface QuotaExemptRoute {
+    method: 'GET' | 'POST';
+    /** Anchored pattern over the service-local path. */
+    path: RegExp;
+    /** Who calls it, and why it must be free. */
+    reason: string;
+}
+export declare const QUOTA_EXEMPT_ROUTES: readonly QuotaExemptRoute[];
+/** Whether `method` + `path` (a request path or a route-table pattern) is quota-exempt. */
+export declare function isQuotaExemptRoute(method: string | undefined, path: string): boolean;