@pipeline-builder/api-core 0.0.1

package/lib/middleware/index.d.ts

@@ -0,0 +1,3 @@
+export * from './auth.js';
+export * from './mongo-sanitize.js';
+export * from './step-up.js';

package/lib/middleware/index.js

@@ -0,0 +1,6 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+export * from './auth.js';
+export * from './mongo-sanitize.js';
+export * from './step-up.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWlkZGxld2FyZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuZXhwb3J0ICogZnJvbSAnLi9hdXRoLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vbW9uZ28tc2FuaXRpemUuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9zdGVwLXVwLmpzJztcbiJdfQ==

package/lib/middleware/mongo-sanitize.d.ts

@@ -0,0 +1,32 @@
+import type { NextFunction, Request, Response } from 'express';
+/** Maximum nesting depth accepted by {@link mongoSanitize}. */
+export declare const MAX_SANITIZE_DEPTH = 10;
+/**
+ * Thrown when a request payload nests deeper than {@link MAX_SANITIZE_DEPTH}.
+ * The middleware maps this to HTTP 400 instead of silently truncating the walk
+ * (which would let operator-shaped keys below the cap slip through unsanitized).
+ */
+export declare class PayloadTooDeepError extends Error {
+    readonly statusCode: 400;
+    constructor(message?: string);
+}
+/**
+ * MongoDB operator-injection middleware.
+ *
+ * Recursively strips object keys starting with `$` (Mongo operators like
+ * `$ne`, `$gt`, `$where`) and keys containing `.` (dot-walks) from
+ * `req.body`, `req.query`, and `req.params`. Without this, a JSON request
+ * like `{"email": {"$ne": null}}` against a Mongo-backed service can match
+ * any document — Zod catches the wrong *type* but won't reach into nested
+ * objects to strip operator-shaped keys.
+ *
+ * Apply BEFORE any Mongo query handler (typically right after
+ * `express.json()`). Postgres-backed services don't need it.
+ *
+ * `req.body` and `req.params` are plain writable objects, so they're sanitized
+ * in place. On Express 5 `req.query` is a GETTER that re-parses the URL and
+ * returns a fresh object on every access — mutating it is a no-op — so we
+ * sanitize a snapshot and pin it onto the request instance with
+ * `Object.defineProperty`, shadowing the getter for all downstream reads.
+ */
+export declare function mongoSanitize(): (req: Request, res: Response, next: NextFunction) => void;

package/lib/middleware/mongo-sanitize.js

@@ -0,0 +1,100 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { HttpStatus } from '../constants/http-status.js';
+import { ErrorCode } from '../types/error-codes.js';
+import { sendError } from '../utils/response.js';
+/** Maximum nesting depth accepted by {@link mongoSanitize}. */
+export const MAX_SANITIZE_DEPTH = 10;
+/**
+ * Thrown when a request payload nests deeper than {@link MAX_SANITIZE_DEPTH}.
+ * The middleware maps this to HTTP 400 instead of silently truncating the walk
+ * (which would let operator-shaped keys below the cap slip through unsanitized).
+ */
+export class PayloadTooDeepError extends Error {
+    statusCode = HttpStatus.BAD_REQUEST;
+    constructor(message = `Request payload nesting exceeds the maximum depth of ${MAX_SANITIZE_DEPTH}`) {
+        super(message);
+        this.name = 'PayloadTooDeepError';
+    }
+}
+/**
+ * MongoDB operator-injection middleware.
+ *
+ * Recursively strips object keys starting with `$` (Mongo operators like
+ * `$ne`, `$gt`, `$where`) and keys containing `.` (dot-walks) from
+ * `req.body`, `req.query`, and `req.params`. Without this, a JSON request
+ * like `{"email": {"$ne": null}}` against a Mongo-backed service can match
+ * any document — Zod catches the wrong *type* but won't reach into nested
+ * objects to strip operator-shaped keys.
+ *
+ * Apply BEFORE any Mongo query handler (typically right after
+ * `express.json()`). Postgres-backed services don't need it.
+ *
+ * `req.body` and `req.params` are plain writable objects, so they're sanitized
+ * in place. On Express 5 `req.query` is a GETTER that re-parses the URL and
+ * returns a fresh object on every access — mutating it is a no-op — so we
+ * sanitize a snapshot and pin it onto the request instance with
+ * `Object.defineProperty`, shadowing the getter for all downstream reads.
+ */
+export function mongoSanitize() {
+    return (req, res, next) => {
+        try {
+            if (req.body && typeof req.body === 'object')
+                sanitizeObject(req.body);
+            if (req.params && typeof req.params === 'object')
+                sanitizeObject(req.params);
+            if (req.query && typeof req.query === 'object') {
+                const q = req.query;
+                sanitizeObject(q);
+                // Pin the sanitized snapshot so the Express 5 getter can't re-parse a
+                // fresh (unsanitized) object on the next access.
+                try {
+                    Object.defineProperty(req, 'query', { value: q, writable: true, configurable: true, enumerable: true });
+                }
+                catch {
+                    // Express 4 (writable data prop) — the in-place sanitize above sufficed.
+                }
+            }
+        }
+        catch (err) {
+            // Reject over-deep payloads with a 400 rather than silently truncating
+            // the sanitize walk (which risked leaving deep operator keys in place).
+            if (err instanceof PayloadTooDeepError) {
+                return sendError(res, err.statusCode, err.message, ErrorCode.VALIDATION_ERROR);
+            }
+            throw err;
+        }
+        next();
+    };
+}
+// Prototype-pollution keys — these never belong in JSON request bodies, and a
+// downstream recursive merge/assign on the parsed object could otherwise walk
+// `constructor.prototype` to inject Mongo operators or pollute Object.prototype.
+const FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+function sanitizeObject(obj, depth = 0) {
+    // Reject pathologically nested input rather than silently returning — a
+    // silent cap would leave any operator/dot/prototype keys deeper than the
+    // cap un-sanitized. The middleware maps this to a 400.
+    if (depth > MAX_SANITIZE_DEPTH) {
+        throw new PayloadTooDeepError();
+    }
+    for (const key of Object.keys(obj)) {
+        if (key.startsWith('$') || key.includes('.') || FORBIDDEN_KEYS.has(key)) {
+            delete obj[key];
+            continue;
+        }
+        const v = obj[key];
+        if (v && typeof v === 'object') {
+            if (Array.isArray(v)) {
+                for (const item of v) {
+                    if (item && typeof item === 'object')
+                        sanitizeObject(item, depth + 1);
+                }
+            }
+            else {
+                sanitizeObject(v, depth + 1);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mongo-sanitize.js","sourceRoot":"","sources":["../../src/middleware/mongo-sanitize.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { NextFunction, Request, Response } from 'express';\nimport { HttpStatus } from '../constants/http-status.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { sendError } from '../utils/response.js';\n\n/** Maximum nesting depth accepted by {@link mongoSanitize}. */\nexport const MAX_SANITIZE_DEPTH = 10;\n\n/**\n * Thrown when a request payload nests deeper than {@link MAX_SANITIZE_DEPTH}.\n * The middleware maps this to HTTP 400 instead of silently truncating the walk\n * (which would let operator-shaped keys below the cap slip through unsanitized).\n */\nexport class PayloadTooDeepError extends Error {\n  readonly statusCode = HttpStatus.BAD_REQUEST;\n  constructor(message = `Request payload nesting exceeds the maximum depth of ${MAX_SANITIZE_DEPTH}`) {\n    super(message);\n    this.name = 'PayloadTooDeepError';\n  }\n}\n\n/**\n * MongoDB operator-injection middleware.\n *\n * Recursively strips object keys starting with `$` (Mongo operators like\n * `$ne`, `$gt`, `$where`) and keys containing `.` (dot-walks) from\n * `req.body`, `req.query`, and `req.params`. Without this, a JSON request\n * like `{\"email\": {\"$ne\": null}}` against a Mongo-backed service can match\n * any document — Zod catches the wrong *type* but won't reach into nested\n * objects to strip operator-shaped keys.\n *\n * Apply BEFORE any Mongo query handler (typically right after\n * `express.json()`). Postgres-backed services don't need it.\n *\n * `req.body` and `req.params` are plain writable objects, so they're sanitized\n * in place. On Express 5 `req.query` is a GETTER that re-parses the URL and\n * returns a fresh object on every access — mutating it is a no-op — so we\n * sanitize a snapshot and pin it onto the request instance with\n * `Object.defineProperty`, shadowing the getter for all downstream reads.\n */\nexport function mongoSanitize() {\n  return (req: Request, res: Response, next: NextFunction) => {\n    try {\n      if (req.body && typeof req.body === 'object') sanitizeObject(req.body);\n      if (req.params && typeof req.params === 'object') sanitizeObject(req.params as Record<string, unknown>);\n      if (req.query && typeof req.query === 'object') {\n        const q = req.query as Record<string, unknown>;\n        sanitizeObject(q);\n        // Pin the sanitized snapshot so the Express 5 getter can't re-parse a\n        // fresh (unsanitized) object on the next access.\n        try {\n          Object.defineProperty(req, 'query', { value: q, writable: true, configurable: true, enumerable: true });\n        } catch {\n          // Express 4 (writable data prop) — the in-place sanitize above sufficed.\n        }\n      }\n    } catch (err) {\n      // Reject over-deep payloads with a 400 rather than silently truncating\n      // the sanitize walk (which risked leaving deep operator keys in place).\n      if (err instanceof PayloadTooDeepError) {\n        return sendError(res, err.statusCode, err.message, ErrorCode.VALIDATION_ERROR);\n      }\n      throw err;\n    }\n    next();\n  };\n}\n\n// Prototype-pollution keys — these never belong in JSON request bodies, and a\n// downstream recursive merge/assign on the parsed object could otherwise walk\n// `constructor.prototype` to inject Mongo operators or pollute Object.prototype.\nconst FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);\n\nfunction sanitizeObject(obj: Record<string, unknown>, depth = 0): void {\n  // Reject pathologically nested input rather than silently returning — a\n  // silent cap would leave any operator/dot/prototype keys deeper than the\n  // cap un-sanitized. The middleware maps this to a 400.\n  if (depth > MAX_SANITIZE_DEPTH) {\n    throw new PayloadTooDeepError();\n  }\n  for (const key of Object.keys(obj)) {\n    if (key.startsWith('$') || key.includes('.') || FORBIDDEN_KEYS.has(key)) {\n      delete obj[key];\n      continue;\n    }\n    const v = obj[key];\n    if (v && typeof v === 'object') {\n      if (Array.isArray(v)) {\n        for (const item of v) {\n          if (item && typeof item === 'object') sanitizeObject(item as Record<string, unknown>, depth + 1);\n        }\n      } else {\n        sanitizeObject(v as Record<string, unknown>, depth + 1);\n      }\n    }\n  }\n}\n"]}

package/lib/middleware/step-up.d.ts

@@ -0,0 +1,45 @@
+/**
+ * `requireStepUp` — a shared step-up (recent-password-reverify) gate for the
+ * stateless api services, mirroring the platform middleware of the same name.
+ *
+ * Flow: the UI hits `POST /api/auth/step-up` (platform) to re-verify the user's
+ * password; platform mints a short-lived (60s) `step-up` JWT signed with the
+ * SAME `JWT_SECRET` these services already verify access tokens with. The UI
+ * replays it as the `X-Step-Up-Token` header on the destructive/sensitive call;
+ * this middleware verifies it, binds it to the caller (`sub` match), and
+ * consumes its `jti` once (Redis-backed cross-instance when configured, else a
+ * bounded process-local set) so a replay inside the TTL is rejected.
+ *
+ * WHY here: restore endpoints on the api services (pipeline/plugin/...) are
+ * step-up-gated, but step-up previously lived only in `platform`. This ports the
+ * verify + single-use jti into api-core so any service can require it.
+ */
+import type { Request, Response, NextFunction } from 'express';
+/** Payload of a platform-issued step-up token (see platform issueStepUpToken). */
+export interface StepUpTokenPayload {
+    type: 'step-up';
+    sub: string;
+    jti: string;
+    iat: number;
+    exp: number;
+}
+/**
+ * Verify a step-up token: valid signature (primary `JWT_SECRET`, or
+ * `JWT_SECRET_PREVIOUS` during a rotation), allow-listed algorithm, AND the
+ * `type: 'step-up'` + `jti` claims — a plain access token shares the secret and
+ * `sub`, so without asserting the step-up shape it would bypass the gate.
+ * Throws on any failure. Does NOT bind to a caller — `requireStepUp` does the
+ * `sub` match and single-use consume.
+ */
+export declare function verifyStepUpToken(token: string): StepUpTokenPayload;
+/**
+ * Consume a step-up `jti` exactly once. Returns true if this call claimed it
+ * (first use), false if it was already consumed (replay). `expEpochSeconds` is
+ * the token's `exp`, so the marker auto-expires with the token.
+ */
+export declare function consumeStepUpJti(jti: string, expEpochSeconds: number): Promise<boolean>;
+/**
+ * Express middleware: require a valid, caller-bound, single-use step-up token in
+ * the `X-Step-Up-Token` header. Must run AFTER `requireAuth` (needs `req.user`).
+ */
+export declare function requireStepUp(req: Request, res: Response, next: NextFunction): Promise<void>;

package/lib/middleware/step-up.js

@@ -0,0 +1,138 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import jwt from 'jsonwebtoken';
+import { isServicePrincipal } from './auth.js';
+import { createEnvRedisClient } from '../services/env-redis.js';
+import { getHeaderString } from '../utils/headers.js';
+import { createLogger } from '../utils/logger.js';
+import { sendError } from '../utils/response.js';
+const logger = createLogger('step-up');
+const HEADER = 'x-step-up-token';
+function jwtAlgorithm() {
+    return (process.env.JWT_ALGORITHM || 'HS256');
+}
+/**
+ * Verify a step-up token: valid signature (primary `JWT_SECRET`, or
+ * `JWT_SECRET_PREVIOUS` during a rotation), allow-listed algorithm, AND the
+ * `type: 'step-up'` + `jti` claims — a plain access token shares the secret and
+ * `sub`, so without asserting the step-up shape it would bypass the gate.
+ * Throws on any failure. Does NOT bind to a caller — `requireStepUp` does the
+ * `sub` match and single-use consume.
+ */
+export function verifyStepUpToken(token) {
+    const secret = process.env.JWT_SECRET;
+    if (!secret)
+        throw new Error('JWT_SECRET environment variable is required');
+    const opts = { algorithms: [jwtAlgorithm()] };
+    let payload;
+    try {
+        payload = jwt.verify(token, secret, opts);
+    }
+    catch (primaryErr) {
+        const previous = process.env.JWT_SECRET_PREVIOUS;
+        if (!previous)
+            throw primaryErr;
+        payload = jwt.verify(token, previous, opts);
+    }
+    if (payload.type !== 'step-up' || !payload.jti || !payload.sub) {
+        throw new Error('INVALID_STEP_UP_TOKEN');
+    }
+    return payload;
+}
+// -- Single-use jti store -----------------------------------------------------
+// Redis SET NX EX when Redis is configured (cross-instance single-use); else a
+// bounded process-local map with TTL sweep (per-process). A step-up token is
+// 60s-lived. When Redis IS configured it's the authoritative store: a Redis
+// error FAILS CLOSED (throws → STEP_UP_INVALID, user re-verifies) rather than
+// degrading to the per-instance mem guard, which would accept a cross-instance
+// replay during the outage. The mem guard is used ONLY when Redis is absent.
+let _redis;
+function redis() {
+    if (_redis === undefined) {
+        _redis = createEnvRedisClient('step-up-jti');
+    }
+    return _redis;
+}
+const memJti = new Map(); // jti -> expiry epoch ms
+const memSweep = setInterval(() => {
+    const now = Date.now();
+    for (const [jti, exp] of memJti)
+        if (exp <= now)
+            memJti.delete(jti);
+}, 30_000);
+memSweep.unref?.();
+/**
+ * Consume a step-up `jti` exactly once. Returns true if this call claimed it
+ * (first use), false if it was already consumed (replay). `expEpochSeconds` is
+ * the token's `exp`, so the marker auto-expires with the token.
+ */
+export async function consumeStepUpJti(jti, expEpochSeconds) {
+    const ttlSeconds = Math.max(1, expEpochSeconds - Math.floor(Date.now() / 1000));
+    const client = redis();
+    if (client) {
+        // Redis configured ⇒ authoritative cross-instance store. SET NX EX → 'OK'
+        // when newly set, null when already consumed. A thrown Redis error is NOT
+        // caught here: it propagates so `requireStepUp` fails closed (STEP_UP_INVALID)
+        // instead of silently degrading to the per-instance mem guard.
+        const res = await client.set(`stepup:jti:${jti}`, '1', 'EX', ttlSeconds, 'NX');
+        return res === 'OK';
+    }
+    // No Redis ⇒ single-instance deployment; the process-local map IS the store.
+    if (memJti.has(jti))
+        return false;
+    memJti.set(jti, Date.now() + ttlSeconds * 1000);
+    return true;
+}
+/**
+ * Express middleware: require a valid, caller-bound, single-use step-up token in
+ * the `X-Step-Up-Token` header. Must run AFTER `requireAuth` (needs `req.user`).
+ */
+export async function requireStepUp(req, res, next) {
+    // Verified internal service principals are EXEMPT: step-up is a re-verify-the-
+    // HUMAN gate (they replay a password-reverify token), which a service token
+    // structurally cannot produce. Services already bypass `requirePermission` on
+    // the same trust basis (a signed service JWT), and internal callers of a
+    // step-up-gated route — e.g. the platform org-cascade's `DELETE /quotas/:orgId`
+    // or the billing→quota entitlement sync — would otherwise be hard-blocked.
+    // Safe: a service token can only be minted with `JWT_SECRET`, so this can't be
+    // spoofed by an external client to skip step-up.
+    if (isServicePrincipal(req)) {
+        next();
+        return;
+    }
+    const callerSub = req.user?.sub;
+    if (!callerSub) {
+        sendError(res, 401, 'Authentication required', 'UNAUTHORIZED');
+        return;
+    }
+    const token = getHeaderString(req.headers[HEADER]);
+    if (!token) {
+        sendError(res, 401, 'Step-up verification required', 'STEP_UP_REQUIRED');
+        return;
+    }
+    let payload;
+    try {
+        payload = verifyStepUpToken(token);
+    }
+    catch {
+        sendError(res, 401, 'Step-up token invalid or expired', 'STEP_UP_INVALID');
+        return;
+    }
+    if (payload.sub !== callerSub) {
+        sendError(res, 401, 'Step-up token does not match session', 'STEP_UP_MISMATCH');
+        return;
+    }
+    try {
+        if (!(await consumeStepUpJti(payload.jti, payload.exp))) {
+            sendError(res, 401, 'Step-up token already used or expired', 'STEP_UP_REPLAY');
+            return;
+        }
+    }
+    catch (err) {
+        logger.error('Step-up jti consume errored', { error: String(err) });
+        sendError(res, 401, 'Step-up verification failed', 'STEP_UP_INVALID');
+        return;
+    }
+    next();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-up.js","sourceRoot":"","sources":["../../src/middleware/step-up.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * `requireStepUp` — a shared step-up (recent-password-reverify) gate for the\n * stateless api services, mirroring the platform middleware of the same name.\n *\n * Flow: the UI hits `POST /api/auth/step-up` (platform) to re-verify the user's\n * password; platform mints a short-lived (60s) `step-up` JWT signed with the\n * SAME `JWT_SECRET` these services already verify access tokens with. The UI\n * replays it as the `X-Step-Up-Token` header on the destructive/sensitive call;\n * this middleware verifies it, binds it to the caller (`sub` match), and\n * consumes its `jti` once (Redis-backed cross-instance when configured, else a\n * bounded process-local set) so a replay inside the TTL is rejected.\n *\n * WHY here: restore endpoints on the api services (pipeline/plugin/...) are\n * step-up-gated, but step-up previously lived only in `platform`. This ports the\n * verify + single-use jti into api-core so any service can require it.\n */\n\nimport type { Request, Response, NextFunction } from 'express';\nimport jwt from 'jsonwebtoken';\nimport { isServicePrincipal } from './auth.js';\nimport { createEnvRedisClient } from '../services/env-redis.js';\nimport { getHeaderString } from '../utils/headers.js';\nimport { createLogger } from '../utils/logger.js';\nimport { sendError } from '../utils/response.js';\n\nconst logger = createLogger('step-up');\nconst HEADER = 'x-step-up-token';\n\n/** Payload of a platform-issued step-up token (see platform issueStepUpToken). */\nexport interface StepUpTokenPayload {\n  type: 'step-up';\n  sub: string;\n  jti: string;\n  iat: number;\n  exp: number;\n}\n\nfunction jwtAlgorithm(): jwt.Algorithm {\n  return (process.env.JWT_ALGORITHM || 'HS256') as jwt.Algorithm;\n}\n\n/**\n * Verify a step-up token: valid signature (primary `JWT_SECRET`, or\n * `JWT_SECRET_PREVIOUS` during a rotation), allow-listed algorithm, AND the\n * `type: 'step-up'` + `jti` claims — a plain access token shares the secret and\n * `sub`, so without asserting the step-up shape it would bypass the gate.\n * Throws on any failure. Does NOT bind to a caller — `requireStepUp` does the\n * `sub` match and single-use consume.\n */\nexport function verifyStepUpToken(token: string): StepUpTokenPayload {\n  const secret = process.env.JWT_SECRET;\n  if (!secret) throw new Error('JWT_SECRET environment variable is required');\n  const opts: jwt.VerifyOptions = { algorithms: [jwtAlgorithm()] };\n\n  let payload: StepUpTokenPayload;\n  try {\n    payload = jwt.verify(token, secret, opts) as StepUpTokenPayload;\n  } catch (primaryErr) {\n    const previous = process.env.JWT_SECRET_PREVIOUS;\n    if (!previous) throw primaryErr;\n    payload = jwt.verify(token, previous, opts) as StepUpTokenPayload;\n  }\n\n  if (payload.type !== 'step-up' || !payload.jti || !payload.sub) {\n    throw new Error('INVALID_STEP_UP_TOKEN');\n  }\n  return payload;\n}\n\n// -- Single-use jti store -----------------------------------------------------\n// Redis SET NX EX when Redis is configured (cross-instance single-use); else a\n// bounded process-local map with TTL sweep (per-process). A step-up token is\n// 60s-lived. When Redis IS configured it's the authoritative store: a Redis\n// error FAILS CLOSED (throws → STEP_UP_INVALID, user re-verifies) rather than\n// degrading to the per-instance mem guard, which would accept a cross-instance\n// replay during the outage. The mem guard is used ONLY when Redis is absent.\n\nlet _redis: { set: (...args: unknown[]) => Promise<unknown> } | null | undefined;\nfunction redis(): { set: (...args: unknown[]) => Promise<unknown> } | null {\n  if (_redis === undefined) {\n    _redis = createEnvRedisClient<{ set: (...args: unknown[]) => Promise<unknown> }>('step-up-jti');\n  }\n  return _redis;\n}\n\nconst memJti = new Map<string, number>(); // jti -> expiry epoch ms\nconst memSweep = setInterval(() => {\n  const now = Date.now();\n  for (const [jti, exp] of memJti) if (exp <= now) memJti.delete(jti);\n}, 30_000);\nmemSweep.unref?.();\n\n/**\n * Consume a step-up `jti` exactly once. Returns true if this call claimed it\n * (first use), false if it was already consumed (replay). `expEpochSeconds` is\n * the token's `exp`, so the marker auto-expires with the token.\n */\nexport async function consumeStepUpJti(jti: string, expEpochSeconds: number): Promise<boolean> {\n  const ttlSeconds = Math.max(1, expEpochSeconds - Math.floor(Date.now() / 1000));\n  const client = redis();\n  if (client) {\n    // Redis configured ⇒ authoritative cross-instance store. SET NX EX → 'OK'\n    // when newly set, null when already consumed. A thrown Redis error is NOT\n    // caught here: it propagates so `requireStepUp` fails closed (STEP_UP_INVALID)\n    // instead of silently degrading to the per-instance mem guard.\n    const res = await client.set(`stepup:jti:${jti}`, '1', 'EX', ttlSeconds, 'NX');\n    return res === 'OK';\n  }\n  // No Redis ⇒ single-instance deployment; the process-local map IS the store.\n  if (memJti.has(jti)) return false;\n  memJti.set(jti, Date.now() + ttlSeconds * 1000);\n  return true;\n}\n\n/**\n * Express middleware: require a valid, caller-bound, single-use step-up token in\n * the `X-Step-Up-Token` header. Must run AFTER `requireAuth` (needs `req.user`).\n */\nexport async function requireStepUp(req: Request, res: Response, next: NextFunction): Promise<void> {\n  // Verified internal service principals are EXEMPT: step-up is a re-verify-the-\n  // HUMAN gate (they replay a password-reverify token), which a service token\n  // structurally cannot produce. Services already bypass `requirePermission` on\n  // the same trust basis (a signed service JWT), and internal callers of a\n  // step-up-gated route — e.g. the platform org-cascade's `DELETE /quotas/:orgId`\n  // or the billing→quota entitlement sync — would otherwise be hard-blocked.\n  // Safe: a service token can only be minted with `JWT_SECRET`, so this can't be\n  // spoofed by an external client to skip step-up.\n  if (isServicePrincipal(req)) {\n    next();\n    return;\n  }\n\n  const callerSub = (req as Request & { user?: { sub?: string } }).user?.sub;\n  if (!callerSub) {\n    sendError(res, 401, 'Authentication required', 'UNAUTHORIZED');\n    return;\n  }\n\n  const token = getHeaderString(req.headers[HEADER]);\n  if (!token) {\n    sendError(res, 401, 'Step-up verification required', 'STEP_UP_REQUIRED');\n    return;\n  }\n\n  let payload: StepUpTokenPayload;\n  try {\n    payload = verifyStepUpToken(token);\n  } catch {\n    sendError(res, 401, 'Step-up token invalid or expired', 'STEP_UP_INVALID');\n    return;\n  }\n\n  if (payload.sub !== callerSub) {\n    sendError(res, 401, 'Step-up token does not match session', 'STEP_UP_MISMATCH');\n    return;\n  }\n\n  try {\n    if (!(await consumeStepUpJti(payload.jti, payload.exp))) {\n      sendError(res, 401, 'Step-up token already used or expired', 'STEP_UP_REPLAY');\n      return;\n    }\n  } catch (err) {\n    logger.error('Step-up jti consume errored', { error: String(err) });\n    sendError(res, 401, 'Step-up verification failed', 'STEP_UP_INVALID');\n    return;\n  }\n\n  next();\n}\n"]}

package/lib/openapi/extend-zod.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/openapi/extend-zod.js

@@ -0,0 +1,6 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { extendZodWithOpenApi } from '@asteasolutions/zod-to-openapi';
+import { z } from 'zod';
+extendZodWithOpenApi(z);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXh0ZW5kLXpvZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9vcGVuYXBpL2V4dGVuZC16b2QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUV0QyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN0RSxPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBRXhCLG9CQUFvQixDQUFDLENBQUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbmltcG9ydCB7IGV4dGVuZFpvZFdpdGhPcGVuQXBpIH0gZnJvbSAnQGFzdGVhc29sdXRpb25zL3pvZC10by1vcGVuYXBpJztcbmltcG9ydCB7IHogfSBmcm9tICd6b2QnO1xuXG5leHRlbmRab2RXaXRoT3BlbkFwaSh6KTtcbiJdfQ==

package/lib/openapi/index.d.ts

@@ -0,0 +1,2 @@
+export { registry, generateOpenApiSpec } from './registry.js';
+export type { OpenApiSpecOptions } from './registry.js';

package/lib/openapi/index.js

@@ -0,0 +1,5 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+// Public API
+export { registry, generateOpenApiSpec } from './registry.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvb3BlbmFwaS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLGFBQWE7QUFDYixPQUFPLEVBQUUsUUFBUSxFQUFFLG1CQUFtQixFQUFFLE1BQU0sZUFBZSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbi8vIFB1YmxpYyBBUElcbmV4cG9ydCB7IHJlZ2lzdHJ5LCBnZW5lcmF0ZU9wZW5BcGlTcGVjIH0gZnJvbSAnLi9yZWdpc3RyeS5qcyc7XG5leHBvcnQgdHlwZSB7IE9wZW5BcGlTcGVjT3B0aW9ucyB9IGZyb20gJy4vcmVnaXN0cnkuanMnO1xuIl19

package/lib/openapi/registry.d.ts

@@ -0,0 +1,17 @@
+import { OpenAPIRegistry, OpenApiGeneratorV31 } from '@asteasolutions/zod-to-openapi';
+/** Shared OpenAPI registry for all schema and path registrations. */
+export declare const registry: OpenAPIRegistry;
+/** Options for customizing the generated OpenAPI spec. */
+export interface OpenApiSpecOptions {
+    title?: string;
+    version?: string;
+    description?: string;
+    serverUrl?: string;
+}
+/**
+ * Generate the complete OpenAPI 3.1.0 specification document.
+ *
+ * @param options - Optional overrides for spec metadata
+ * @returns OpenAPI 3.1 specification object
+ */
+export declare function generateOpenApiSpec(options?: OpenApiSpecOptions): ReturnType<OpenApiGeneratorV31['generateDocument']>;

package/lib/openapi/registry.js

@@ -0,0 +1,38 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { OpenAPIRegistry, OpenApiGeneratorV31 } from '@asteasolutions/zod-to-openapi';
+import { registerAllRoutes } from './routes/index.js';
+import { registerSchemas } from './schema-registry.js';
+/** Shared OpenAPI registry for all schema and path registrations. */
+export const registry = new OpenAPIRegistry();
+let _initialized = false;
+/** Execute all registrations once. */
+function ensureInitialized() {
+    if (_initialized)
+        return;
+    _initialized = true;
+    registerSchemas();
+    registerAllRoutes();
+}
+/**
+ * Generate the complete OpenAPI 3.1.0 specification document.
+ *
+ * @param options - Optional overrides for spec metadata
+ * @returns OpenAPI 3.1 specification object
+ */
+export function generateOpenApiSpec(options) {
+    ensureInitialized();
+    const generator = new OpenApiGeneratorV31(registry.definitions);
+    return generator.generateDocument({
+        openapi: '3.1.0',
+        info: {
+            title: options?.title ?? 'Pipeline Builder API',
+            version: options?.version ?? '1.0.0',
+            description: options?.description ?? 'CI/CD Pipeline Builder Platform API — manage pipelines, plugins, messages, quotas, and billing.',
+        },
+        servers: [
+            { url: options?.serverUrl ?? '/api', description: 'API base path' },
+        ],
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/openapi/routes/ask-routes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * OpenAPI definitions for the "Ask" assistant service (api/ask), mounted at
+ * `/ask`. All routes are gated by the `ai_generation` feature and are READ /
+ * PROPOSE only — the agent never mutates; `propose_*` tool results are drafts the
+ * user confirms in the UI.
+ */
+export declare function registerAskRoutes(): void;

package/lib/openapi/routes/ask-routes.js

@@ -0,0 +1,62 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { registry } from '../registry.js';
+const tags = ['Ask'];
+const auth = [{ bearerAuth: [] }];
+/**
+ * OpenAPI definitions for the "Ask" assistant service (api/ask), mounted at
+ * `/ask`. All routes are gated by the `ai_generation` feature and are READ /
+ * PROPOSE only — the agent never mutates; `propose_*` tool results are drafts the
+ * user confirms in the UI.
+ */
+export function registerAskRoutes() {
+    registry.registerPath({
+        method: 'get',
+        path: '/ask/providers',
+        summary: 'List configured AI providers',
+        description: 'The AI providers/models available to the Ask assistant (from server env — cloud keys and/or the OpenAI-compatible local endpoint).',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Configured providers' }, 403: { description: 'ai_generation feature required' } },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/ask',
+        summary: 'Grounded how-to answer (non-streaming)',
+        description: 'Answer a platform how-to question grounded in the docs corpus. Reserves one aiCalls quota slot.',
+        tags,
+        security: auth,
+        responses: {
+            200: { description: 'Answer with grounded sources' },
+            403: { description: 'ai_generation feature required' },
+            429: { description: 'aiCalls quota exceeded or rate limited' },
+        },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/ask/stream',
+        summary: 'Grounded how-to answer (SSE stream)',
+        description: 'Same as POST /ask but streams the grounded sources then answer tokens as Server-Sent Events.',
+        tags,
+        security: auth,
+        responses: {
+            200: { description: 'text/event-stream of sources + answer tokens' },
+            403: { description: 'ai_generation feature required' },
+            429: { description: 'aiCalls quota exceeded or rate limited' },
+        },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/ask/agent/stream',
+        summary: 'Tool-calling Ask agent (SSE stream)',
+        description: 'Runs the tool-calling assistant loop and streams reasoning tokens, tool-call events, and reviewable `propose_*` drafts (pipeline/plugin/template) as SSE. Read-only: proposals are confirmed separately in the UI.',
+        tags,
+        security: auth,
+        responses: {
+            200: { description: 'text/event-stream of tokens, tool-calls, and proposal drafts' },
+            403: { description: 'ai_generation feature required' },
+            429: { description: 'aiCalls quota exceeded or rate limited' },
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/openapi/routes/billing-routes.d.ts

@@ -0,0 +1 @@
+export declare function registerBillingRoutes(): void;

package/lib/openapi/routes/billing-routes.js

@@ -0,0 +1,66 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { registry } from '../registry.js';
+const tags = ['Billing'];
+const auth = [{ bearerAuth: [] }];
+export function registerBillingRoutes() {
+    registry.registerPath({
+        method: 'get',
+        path: '/billing/plans',
+        summary: 'List active plans',
+        description: 'List all active billing plans. No authentication required.',
+        tags,
+        responses: { 200: { description: 'List of active billing plans' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/billing/plans/{planId}',
+        summary: 'Get plan by ID',
+        tags,
+        responses: { 200: { description: 'Plan details' }, 404: { description: 'Plan not found' } },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/billing/subscriptions',
+        summary: 'Create subscription',
+        description: 'Create a new billing subscription for the current organization.',
+        tags,
+        security: auth,
+        responses: { 201: { description: 'Subscription created' }, 400: { description: 'Validation error' } },
+    });
+    registry.registerPath({
+        method: 'get',
+        path: '/billing/subscriptions',
+        summary: 'List subscriptions',
+        description: 'List billing subscriptions for the current organization.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'List of subscriptions' } },
+    });
+    registry.registerPath({
+        method: 'put',
+        path: '/billing/subscriptions/{id}',
+        summary: 'Update subscription',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Subscription updated' }, 404: { description: 'Not found' } },
+    });
+    registry.registerPath({
+        method: 'delete',
+        path: '/billing/subscriptions/{id}',
+        summary: 'Cancel subscription',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Subscription cancelled' }, 404: { description: 'Not found' } },
+    });
+    registry.registerPath({
+        method: 'post',
+        path: '/billing/marketplace',
+        summary: 'AWS Marketplace integration',
+        description: 'Handle AWS Marketplace subscription events.',
+        tags,
+        security: auth,
+        responses: { 200: { description: 'Marketplace event processed' } },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/openapi/routes/image-registry-routes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * OpenAPI definitions for the image-registry service (api/image-registry): the
+ * Docker-registry token endpoint (`/token`), the org-scoped image API
+ * (`/api/images`), and the admin API (`/api/admin`). Image read/write is gated by
+ * the `registry:read` / `registry:write` permissions.
+ */
+export declare function registerImageRegistryRoutes(): void;