@pipeline-builder/api-core 4.1.13 → 4.1.14

package/lib/index.js

@@ -21,7 +21,7 @@
  * **Utilities**
  * - createLogger — Winston-based structured logger factory
  * - sendSuccess, sendError, sendPaginatedNested, sendBadRequest, sendInternalError — HTTP response helpers
- * - getParam, getOrgId — request parameter extraction
+ * - getParam — request parameter extraction
  * - parseQueryInt, parseQueryString — query string parsing
  * - getIdentity — identity extraction from requests
  * - actorId — the audit actor for a route context (one `system` sentinel)
@@ -54,25 +54,27 @@
  * PUBLIC SURFACE POLICY
  *
  * The root re-exports the ten sub-barrels, and each SUB-BARREL is the allow-list
- * for its own area — that is where a module is either `export *`'d or narrowed
- * to the names services may use. Internals are excluded there rather than here,
- * so the exclusion sits next to the code that defines them and cannot be missed
- * by someone adding a module.
+ * for its own area: every re-export NAMES what it exports (no `export *`), and
+ * a name is on the list only because some other package — a service, the
+ * frontend, a test, a deploy script — actually imports it. Internals are
+ * excluded there rather than here, so the exclusion sits next to the code that
+ * defines them. Adding an export to a module does NOT publish it; add it to
+ * the sub-barrel when a consumer needs it.
  *
- * Currently narrowed (the rest is the intended surface):
- * - `services/retry-strategy` — decision functions only; `parseRetryAfter` and
- *   `addJitter` are backoff internals.
- * - `services/circuit-breaker` — `CircuitOpenError` + `resetCircuitBreakers`;
- *   the `CircuitBreaker` class is wired by the shared HTTP client, not by
- *   services.
+ * Deliberately internal, for example:
+ * - `services/retry-strategy` — decision functions only; `parseRetryAfter`,
+ *   `addJitter` and the DEFAULT_* constants are backoff internals.
+ * - `services/circuit-breaker` — `resetCircuitBreakers` only; the
+ *   `CircuitBreaker` class is wired by the shared HTTP client, not by services.
  * - `services/service-keys` — verify/inspect only; signing, the key bundle and
  *   `_resetServiceKeysForTests` stay inside.
  * - `utils/jwk` — constants, shapes, decoders and the two signer-facing helpers
  *   platform needs; `jwkThumbprint` / `publicKeyFromJwk` stay inside.
  *
- * api-core's own modules and its `testing/` helpers reach the excluded symbols
- * by DEEP import (`@pipeline-builder/api-core/lib/services/service-keys.js`),
- * which is also how the unit tests reach them.
+ * api-core's own modules reach the excluded symbols by relative import; unit
+ * tests reach them by DEEP import
+ * (`@pipeline-builder/api-core/lib/services/service-keys.js`). Test helpers are
+ * the separate `@pipeline-builder/api-core/testing` entry, never this barrel.
  */
 // Types
 export * from './types/index.js';
@@ -94,4 +96,4 @@ export * from './errors/index.js';
 export * from './validation/index.js';
 // OpenAPI
 export * from './openapi/index.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/middleware/assurance.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Session-assurance gates: minimum AAL / max auth age for a person's session,
+ * and the org-admin MFA policy.
+ */
+import type { Request, Response, NextFunction } from 'express';
+import { type OrgAdminAssuranceMachines } from './route-table.js';
+import { type AssuranceLevel, type JwtPayload } from '../types/common.js';
+import { ErrorCode } from '../types/error-codes.js';
+/**
+ * Whether a set of verified claims speaks for a PERSON's own session — the only
+ * kind of credential an assurance level can be asserted about.
+ *
+ * Excludes all three machine shapes: an internal service principal, an org
+ * service account, and any exchanged access key (`token_use: 'api_key'`, i.e. a
+ * PAT or a service-account key), each of which authenticates a program holding a
+ * secret rather than a person presenting factors.
+ */
+export declare function isHumanPrincipal(claims: Pick<JwtPayload, 'principalType' | 'token_use'> | undefined): boolean;
+/** What an assurance gate demands. */
+export interface AssuranceOptions {
+    minAssurance: AssuranceLevel;
+    maxAge?: number;
+    /**
+     * A NAMED carve-out for requests that cannot possibly satisfy the level and
+     * must still be served — today only one exists: the bootstrap-administrator
+     * window, where a fresh install's single admin has no factor yet and the setup
+     * calls that create the install's automation credential would otherwise be
+     * unreachable (see platform's `isBootstrapSetupRequest`).
+     *
+     * It is deliberately shaped as `{ reason, when }` rather than a bare predicate:
+     * the reason is counted (`assurance_exempted_total{reason}`) and published on
+     * the route table as `assuranceExempt`, so an exemption cannot be added without
+     * showing up in the generated table a reviewer reads. The gate keeps its
+     * `minAssurance` tag either way — the route still requires MFA-grade for
+     * everyone the carve-out does not name.
+     */
+    exempt?: {
+        reason: string;
+        when: (req: Request) => boolean;
+    };
+}
+/**
+ * Standalone assurance gate, for a service whose own `requireAuth` is not
+ * api-core's (platform's is its own, because it reads Mongo). Compose it AFTER
+ * authentication: `router.get('/x', requireAuth, requireAssurance({ minAssurance: 2 }), h)`.
+ *
+ * Identical rules and identical refusals to `requireAuth({ minAssurance })` —
+ * that option simply calls the same check inline, so there is one implementation
+ * of "is this session MFA-grade" in the codebase.
+ */
+export declare function requireAssurance(options: AssuranceOptions): (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Handler-level twin of {@link requireAssurance}, for a route where only SOME
+ * requests must be MFA-grade — e.g. a policy route on which TIGHTENING a setting
+ * stays open to a single-factor session (so an admin without MFA can adopt it)
+ * but LOOSENING it does not. Same rules and the same three refusals. Returns
+ * true when the request was REFUSED (a response has been sent).
+ */
+export declare function refuseWeakSession(req: Request, res: Response, options: AssuranceOptions): boolean;
+/** What {@link requireOrgAdminAssurance} demands of a route. */
+export interface OrgAdminAssuranceOptions {
+    /** What a machine credential (PAT, service account, machine session) meets on
+     *  this route while the policy is on — see {@link OrgAdminAssuranceMachines}.
+     *  Required, so every route states its decision rather than inheriting one. */
+    machines: OrgAdminAssuranceMachines;
+}
+/** `details.reason` on a refusal by {@link requireOrgAdminAssurance}, so the UI
+ *  can say it is the ORG's policy asking, not the route's own requirement. */
+export declare const ORG_ADMIN_MFA_REASON = "org_admin_policy";
+/**
+ * The refusal {@link requireOrgAdminAssurance} would send for these claims, or
+ * `undefined` when the request may proceed. Exported so a handler whose policy
+ * applies to only PART of a route (e.g. `generate-token`, where opening a new
+ * machine credential is gated but renewing an existing one is not) applies the
+ * exact same rule rather than a copy of it.
+ */
+export declare function orgAdminAssuranceRefusal(claims: JwtPayload | undefined, options: OrgAdminAssuranceOptions): {
+    status: number;
+    code: ErrorCode;
+    message: string;
+    reason: 'machine_principal' | 'weak_session';
+} | undefined;
+/**
+ * Apply {@link orgAdminAssuranceRefusal} and send its refusal. Returns true when
+ * the request was REFUSED (a response has been sent). For handler-level use;
+ * routes use {@link requireOrgAdminAssurance}.
+ */
+export declare function refuseForOrgAdminAssurance(req: Request, res: Response, options: OrgAdminAssuranceOptions): boolean;
+/**
+ * The org policy "administrative actions require MFA" (`adminActionsRequireMfa`).
+ *
+ * Unlike {@link requireAssurance}, the requirement is the ORG's choice, not the
+ * route's: the gate reads the `org_admin_aal` claim, set at token issue from the
+ * active org's policy (strictest across its ancestors), so a service that cannot
+ * read the org document still enforces it. With the policy off the gate is a
+ * no-op; with it on, a single-factor session is refused 401 `MFA_REQUIRED`
+ * (with `details.reason: 'org_admin_policy'`) — the same code the client already
+ * turns into "enrol a factor / sign in with it", never a sign-out.
+ *
+ * `machines` is decided per route (see {@link OrgAdminAssuranceMachines}): the
+ * policy is about how strongly a PERSON's session was opened, so automation that
+ * legitimately drives a route keeps working (`allow`), while a route that mints
+ * a further credential refuses machines outright (`refuse`, 403
+ * `HUMAN_SESSION_REQUIRED` — the same refusal `requireAssurance` gives them).
+ */
+export declare function requireOrgAdminAssurance(options: OrgAdminAssuranceOptions): (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Enforce `minAssurance` / `maxAge` on a verified token. Returns true when the
+ * request was REFUSED (a response has been sent).
+ *
+ * Three distinct refusals, because the client's next move differs for each:
+ * a machine must stop (403), a weak session must gain a factor (401
+ * `MFA_REQUIRED` → enrolment, never a sign-out), and a stale one must simply
+ * authenticate again (401 `REAUTH_REQUIRED`).
+ */
+export declare function refuseForAssurance(options: AssuranceOptions, decoded: JwtPayload, req: Request, res: Response): boolean;

package/lib/middleware/assurance.js

@@ -0,0 +1,176 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { tagRouteGate } from './route-table.js';
+import { HttpStatus } from '../constants/http-status.js';
+import { serviceIdentity } from '../services/service-keys.js';
+import {} from '../types/common.js';
+import { ErrorCode } from '../types/error-codes.js';
+import { emitCounter } from '../utils/metric-emitter.js';
+import { sendError } from '../utils/response.js';
+import { recordAuthzDenial } from './permission-gates.js';
+/**
+ * Whether a set of verified claims speaks for a PERSON's own session — the only
+ * kind of credential an assurance level can be asserted about.
+ *
+ * Excludes all three machine shapes: an internal service principal, an org
+ * service account, and any exchanged access key (`token_use: 'api_key'`, i.e. a
+ * PAT or a service-account key), each of which authenticates a program holding a
+ * secret rather than a person presenting factors.
+ */
+export function isHumanPrincipal(claims) {
+    return claims?.principalType === 'user' && claims.token_use === 'access';
+}
+/**
+ * Standalone assurance gate, for a service whose own `requireAuth` is not
+ * api-core's (platform's is its own, because it reads Mongo). Compose it AFTER
+ * authentication: `router.get('/x', requireAuth, requireAssurance({ minAssurance: 2 }), h)`.
+ *
+ * Identical rules and identical refusals to `requireAuth({ minAssurance })` —
+ * that option simply calls the same check inline, so there is one implementation
+ * of "is this session MFA-grade" in the codebase.
+ */
+export function requireAssurance(options) {
+    return tagRouteGate((req, res, next) => {
+        if (!req.user) {
+            return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);
+        }
+        // A named exemption is checked AFTER authentication and before the level, so
+        // it can never admit an unauthenticated caller, and it is counted every time
+        // it fires — an exemption nobody can see is how a gate quietly stops being one.
+        if (options.exempt?.when(req) === true) {
+            emitCounter('assurance_exempted_total', { service: serviceIdentity(), reason: options.exempt.reason });
+            return next();
+        }
+        if (refuseForAssurance(options, req.user, req, res))
+            return;
+        next();
+    }, {
+        kind: 'assurance',
+        minAssurance: options.minAssurance,
+        ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}),
+        ...(options.exempt ? { exempt: options.exempt.reason } : {}),
+    });
+}
+/**
+ * Handler-level twin of {@link requireAssurance}, for a route where only SOME
+ * requests must be MFA-grade — e.g. a policy route on which TIGHTENING a setting
+ * stays open to a single-factor session (so an admin without MFA can adopt it)
+ * but LOOSENING it does not. Same rules and the same three refusals. Returns
+ * true when the request was REFUSED (a response has been sent).
+ */
+export function refuseWeakSession(req, res, options) {
+    if (!req.user) {
+        sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);
+        return true;
+    }
+    return refuseForAssurance(options, req.user, req, res);
+}
+/** `details.reason` on a refusal by {@link requireOrgAdminAssurance}, so the UI
+ *  can say it is the ORG's policy asking, not the route's own requirement. */
+export const ORG_ADMIN_MFA_REASON = 'org_admin_policy';
+/**
+ * The refusal {@link requireOrgAdminAssurance} would send for these claims, or
+ * `undefined` when the request may proceed. Exported so a handler whose policy
+ * applies to only PART of a route (e.g. `generate-token`, where opening a new
+ * machine credential is gated but renewing an existing one is not) applies the
+ * exact same rule rather than a copy of it.
+ */
+export function orgAdminAssuranceRefusal(claims, options) {
+    // The claim is only ever `2`, and only when the policy is on (see JwtPayload).
+    if (!claims || claims.org_admin_aal !== 2)
+        return undefined;
+    if (!isHumanPrincipal(claims)) {
+        if (options.machines === 'allow')
+            return undefined;
+        return {
+            status: HttpStatus.FORBIDDEN,
+            code: ErrorCode.HUMAN_SESSION_REQUIRED,
+            reason: 'machine_principal',
+            message: 'Your organization requires two-factor authentication for this action — API keys and service accounts cannot perform it',
+        };
+    }
+    if ((claims.aal ?? 1) >= 2)
+        return undefined;
+    return {
+        status: HttpStatus.UNAUTHORIZED,
+        code: ErrorCode.MFA_REQUIRED,
+        reason: 'weak_session',
+        message: 'Your organization requires two-factor authentication for administrative actions — sign in again with a passkey or an authenticator code',
+    };
+}
+/**
+ * Apply {@link orgAdminAssuranceRefusal} and send its refusal. Returns true when
+ * the request was REFUSED (a response has been sent). For handler-level use;
+ * routes use {@link requireOrgAdminAssurance}.
+ */
+export function refuseForOrgAdminAssurance(req, res, options) {
+    const refusal = orgAdminAssuranceRefusal(req.user, options);
+    if (!refusal)
+        return false;
+    emitCounter('mfa_enforcement_refused_total', { service: serviceIdentity(), reason: `org_admin_${refusal.reason}` });
+    recordAuthzDenial(req, 'assurance:org-admin');
+    sendError(res, refusal.status, refusal.message, refusal.code, { reason: ORG_ADMIN_MFA_REASON });
+    return true;
+}
+/**
+ * The org policy "administrative actions require MFA" (`adminActionsRequireMfa`).
+ *
+ * Unlike {@link requireAssurance}, the requirement is the ORG's choice, not the
+ * route's: the gate reads the `org_admin_aal` claim, set at token issue from the
+ * active org's policy (strictest across its ancestors), so a service that cannot
+ * read the org document still enforces it. With the policy off the gate is a
+ * no-op; with it on, a single-factor session is refused 401 `MFA_REQUIRED`
+ * (with `details.reason: 'org_admin_policy'`) — the same code the client already
+ * turns into "enrol a factor / sign in with it", never a sign-out.
+ *
+ * `machines` is decided per route (see {@link OrgAdminAssuranceMachines}): the
+ * policy is about how strongly a PERSON's session was opened, so automation that
+ * legitimately drives a route keeps working (`allow`), while a route that mints
+ * a further credential refuses machines outright (`refuse`, 403
+ * `HUMAN_SESSION_REQUIRED` — the same refusal `requireAssurance` gives them).
+ */
+export function requireOrgAdminAssurance(options) {
+    return tagRouteGate((req, res, next) => {
+        if (!req.user) {
+            return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);
+        }
+        if (refuseForOrgAdminAssurance(req, res, options))
+            return;
+        next();
+    }, { kind: 'orgAdminAssurance', machines: options.machines });
+}
+/**
+ * Enforce `minAssurance` / `maxAge` on a verified token. Returns true when the
+ * request was REFUSED (a response has been sent).
+ *
+ * Three distinct refusals, because the client's next move differs for each:
+ * a machine must stop (403), a weak session must gain a factor (401
+ * `MFA_REQUIRED` → enrolment, never a sign-out), and a stale one must simply
+ * authenticate again (401 `REAUTH_REQUIRED`).
+ */
+export function refuseForAssurance(options, decoded, req, res) {
+    const minAssurance = options.minAssurance;
+    const refuse = (reason, status, message, code) => {
+        emitCounter('mfa_enforcement_refused_total', { service: serviceIdentity(), reason });
+        recordAuthzDenial(req, `assurance:${minAssurance}`);
+        sendError(res, status, message, code);
+        return true;
+    };
+    if (!isHumanPrincipal(decoded)) {
+        return refuse('machine_principal', HttpStatus.FORBIDDEN, 'This action requires a person signed in with two-factor authentication — API keys and service accounts cannot perform it', ErrorCode.HUMAN_SESSION_REQUIRED);
+    }
+    if ((decoded.aal ?? 1) < minAssurance) {
+        return refuse('weak_session', HttpStatus.UNAUTHORIZED, 'This action requires two-factor authentication — sign in again with a passkey or an authenticator code', ErrorCode.MFA_REQUIRED);
+    }
+    if (options.maxAge !== undefined) {
+        const authTime = decoded.auth_time;
+        // No `auth_time` is not "recent enough by default" — `hasValidIdentityClaims`
+        // already requires it on a user token, so an absent one means a token this
+        // gate cannot reason about. Fail closed.
+        if (typeof authTime !== 'number' || Math.floor(Date.now() / 1000) - authTime > options.maxAge) {
+            return refuse('stale_session', HttpStatus.UNAUTHORIZED, 'This action requires a recent sign-in — please authenticate again', ErrorCode.REAUTH_REQUIRED);
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assurance.js","sourceRoot":"","sources":["../../src/middleware/assurance.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Session-assurance gates: minimum AAL / max auth age for a person's session,\n * and the org-admin MFA policy.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport { tagRouteGate, type OrgAdminAssuranceMachines } from './route-table.js';\nimport { HttpStatus } from '../constants/http-status.js';\nimport { serviceIdentity } from '../services/service-keys.js';\nimport { type AssuranceLevel, type JwtPayload } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { sendError } from '../utils/response.js';\nimport { recordAuthzDenial } from './permission-gates.js';\n/**\n * Whether a set of verified claims speaks for a PERSON's own session — the only\n * kind of credential an assurance level can be asserted about.\n *\n * Excludes all three machine shapes: an internal service principal, an org\n * service account, and any exchanged access key (`token_use: 'api_key'`, i.e. a\n * PAT or a service-account key), each of which authenticates a program holding a\n * secret rather than a person presenting factors.\n */\nexport function isHumanPrincipal(claims: Pick<JwtPayload, 'principalType' | 'token_use'> | undefined): boolean {\n  return claims?.principalType === 'user' && claims.token_use === 'access';\n}\n\n/** What an assurance gate demands. */\nexport interface AssuranceOptions {\n  minAssurance: AssuranceLevel;\n  maxAge?: number;\n  /**\n   * A NAMED carve-out for requests that cannot possibly satisfy the level and\n   * must still be served — today only one exists: the bootstrap-administrator\n   * window, where a fresh install's single admin has no factor yet and the setup\n   * calls that create the install's automation credential would otherwise be\n   * unreachable (see platform's `isBootstrapSetupRequest`).\n   *\n   * It is deliberately shaped as `{ reason, when }` rather than a bare predicate:\n   * the reason is counted (`assurance_exempted_total{reason}`) and published on\n   * the route table as `assuranceExempt`, so an exemption cannot be added without\n   * showing up in the generated table a reviewer reads. The gate keeps its\n   * `minAssurance` tag either way — the route still requires MFA-grade for\n   * everyone the carve-out does not name.\n   */\n  exempt?: { reason: string; when: (req: Request) => boolean };\n}\n\n/**\n * Standalone assurance gate, for a service whose own `requireAuth` is not\n * api-core's (platform's is its own, because it reads Mongo). Compose it AFTER\n * authentication: `router.get('/x', requireAuth, requireAssurance({ minAssurance: 2 }), h)`.\n *\n * Identical rules and identical refusals to `requireAuth({ minAssurance })` —\n * that option simply calls the same check inline, so there is one implementation\n * of \"is this session MFA-grade\" in the codebase.\n */\nexport function requireAssurance(options: AssuranceOptions) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\n    // A named exemption is checked AFTER authentication and before the level, so\n    // it can never admit an unauthenticated caller, and it is counted every time\n    // it fires — an exemption nobody can see is how a gate quietly stops being one.\n    if (options.exempt?.when(req) === true) {\n      emitCounter('assurance_exempted_total', { service: serviceIdentity(), reason: options.exempt.reason });\n      return next();\n    }\n    if (refuseForAssurance(options, req.user as JwtPayload, req, res)) return;\n    next();\n  }, {\n    kind: 'assurance',\n    minAssurance: options.minAssurance,\n    ...(options.maxAge !== undefined ? { maxAge: options.maxAge } : {}),\n    ...(options.exempt ? { exempt: options.exempt.reason } : {}),\n  });\n}\n\n/**\n * Handler-level twin of {@link requireAssurance}, for a route where only SOME\n * requests must be MFA-grade — e.g. a policy route on which TIGHTENING a setting\n * stays open to a single-factor session (so an admin without MFA can adopt it)\n * but LOOSENING it does not. Same rules and the same three refusals. Returns\n * true when the request was REFUSED (a response has been sent).\n */\nexport function refuseWeakSession(req: Request, res: Response, options: AssuranceOptions): boolean {\n  if (!req.user) {\n    sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    return true;\n  }\n  return refuseForAssurance(options, req.user as JwtPayload, req, res);\n}\n\n/** What {@link requireOrgAdminAssurance} demands of a route. */\nexport interface OrgAdminAssuranceOptions {\n  /** What a machine credential (PAT, service account, machine session) meets on\n   *  this route while the policy is on — see {@link OrgAdminAssuranceMachines}.\n   *  Required, so every route states its decision rather than inheriting one. */\n  machines: OrgAdminAssuranceMachines;\n}\n\n/** `details.reason` on a refusal by {@link requireOrgAdminAssurance}, so the UI\n *  can say it is the ORG's policy asking, not the route's own requirement. */\nexport const ORG_ADMIN_MFA_REASON = 'org_admin_policy';\n\n/**\n * The refusal {@link requireOrgAdminAssurance} would send for these claims, or\n * `undefined` when the request may proceed. Exported so a handler whose policy\n * applies to only PART of a route (e.g. `generate-token`, where opening a new\n * machine credential is gated but renewing an existing one is not) applies the\n * exact same rule rather than a copy of it.\n */\nexport function orgAdminAssuranceRefusal(\n  claims: JwtPayload | undefined,\n  options: OrgAdminAssuranceOptions,\n): { status: number; code: ErrorCode; message: string; reason: 'machine_principal' | 'weak_session' } | undefined {\n  // The claim is only ever `2`, and only when the policy is on (see JwtPayload).\n  if (!claims || claims.org_admin_aal !== 2) return undefined;\n  if (!isHumanPrincipal(claims)) {\n    if (options.machines === 'allow') return undefined;\n    return {\n      status: HttpStatus.FORBIDDEN,\n      code: ErrorCode.HUMAN_SESSION_REQUIRED,\n      reason: 'machine_principal',\n      message: 'Your organization requires two-factor authentication for this action — API keys and service accounts cannot perform it',\n    };\n  }\n  if ((claims.aal ?? 1) >= 2) return undefined;\n  return {\n    status: HttpStatus.UNAUTHORIZED,\n    code: ErrorCode.MFA_REQUIRED,\n    reason: 'weak_session',\n    message: 'Your organization requires two-factor authentication for administrative actions — sign in again with a passkey or an authenticator code',\n  };\n}\n\n/**\n * Apply {@link orgAdminAssuranceRefusal} and send its refusal. Returns true when\n * the request was REFUSED (a response has been sent). For handler-level use;\n * routes use {@link requireOrgAdminAssurance}.\n */\nexport function refuseForOrgAdminAssurance(req: Request, res: Response, options: OrgAdminAssuranceOptions): boolean {\n  const refusal = orgAdminAssuranceRefusal(req.user as JwtPayload | undefined, options);\n  if (!refusal) return false;\n  emitCounter('mfa_enforcement_refused_total', { service: serviceIdentity(), reason: `org_admin_${refusal.reason}` });\n  recordAuthzDenial(req, 'assurance:org-admin');\n  sendError(res, refusal.status, refusal.message, refusal.code, { reason: ORG_ADMIN_MFA_REASON });\n  return true;\n}\n\n/**\n * The org policy \"administrative actions require MFA\" (`adminActionsRequireMfa`).\n *\n * Unlike {@link requireAssurance}, the requirement is the ORG's choice, not the\n * route's: the gate reads the `org_admin_aal` claim, set at token issue from the\n * active org's policy (strictest across its ancestors), so a service that cannot\n * read the org document still enforces it. With the policy off the gate is a\n * no-op; with it on, a single-factor session is refused 401 `MFA_REQUIRED`\n * (with `details.reason: 'org_admin_policy'`) — the same code the client already\n * turns into \"enrol a factor / sign in with it\", never a sign-out.\n *\n * `machines` is decided per route (see {@link OrgAdminAssuranceMachines}): the\n * policy is about how strongly a PERSON's session was opened, so automation that\n * legitimately drives a route keeps working (`allow`), while a route that mints\n * a further credential refuses machines outright (`refuse`, 403\n * `HUMAN_SESSION_REQUIRED` — the same refusal `requireAssurance` gives them).\n */\nexport function requireOrgAdminAssurance(options: OrgAdminAssuranceOptions) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\n    if (refuseForOrgAdminAssurance(req, res, options)) return;\n    next();\n  }, { kind: 'orgAdminAssurance', machines: options.machines });\n}\n\n/**\n * Enforce `minAssurance` / `maxAge` on a verified token. Returns true when the\n * request was REFUSED (a response has been sent).\n *\n * Three distinct refusals, because the client's next move differs for each:\n * a machine must stop (403), a weak session must gain a factor (401\n * `MFA_REQUIRED` → enrolment, never a sign-out), and a stale one must simply\n * authenticate again (401 `REAUTH_REQUIRED`).\n */\nexport function refuseForAssurance(\n  options: AssuranceOptions,\n  decoded: JwtPayload,\n  req: Request,\n  res: Response,\n): boolean {\n  const minAssurance = options.minAssurance;\n  const refuse = (reason: string, status: number, message: string, code: ErrorCode): true => {\n    emitCounter('mfa_enforcement_refused_total', { service: serviceIdentity(), reason });\n    recordAuthzDenial(req, `assurance:${minAssurance}`);\n    sendError(res, status, message, code);\n    return true;\n  };\n\n  if (!isHumanPrincipal(decoded)) {\n    return refuse(\n      'machine_principal', HttpStatus.FORBIDDEN,\n      'This action requires a person signed in with two-factor authentication — API keys and service accounts cannot perform it',\n      ErrorCode.HUMAN_SESSION_REQUIRED,\n    );\n  }\n  if ((decoded.aal ?? 1) < minAssurance) {\n    return refuse(\n      'weak_session', HttpStatus.UNAUTHORIZED,\n      'This action requires two-factor authentication — sign in again with a passkey or an authenticator code',\n      ErrorCode.MFA_REQUIRED,\n    );\n  }\n  if (options.maxAge !== undefined) {\n    const authTime = decoded.auth_time;\n    // No `auth_time` is not \"recent enough by default\" — `hasValidIdentityClaims`\n    // already requires it on a user token, so an absent one means a token this\n    // gate cannot reason about. Fail closed.\n    if (typeof authTime !== 'number' || Math.floor(Date.now() / 1000) - authTime > options.maxAge) {\n      return refuse(\n        'stale_session', HttpStatus.UNAUTHORIZED,\n        'This action requires a recent sign-in — please authenticate again',\n        ErrorCode.REAUTH_REQUIRED,\n      );\n    }\n  }\n  return false;\n}\n\n"]}