@pipeline-builder/api-core 3.4.109 → 3.4.110

package/lib/helpers/index.d.ts

@@ -1,5 +1,6 @@
 export * from './crud-helpers.js';
 export * from './access-helpers.js';
+export * from './restore-helpers.js';
 export * from './sse-helpers.js';
 export * from './org-hierarchy.js';
 export * from './org-hierarchy-http.js';

package/lib/helpers/index.js

@@ -2,7 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 export * from './crud-helpers.js';
 export * from './access-helpers.js';
+export * from './restore-helpers.js';
 export * from './sse-helpers.js';
 export * from './org-hierarchy.js';
 export * from './org-hierarchy-http.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaGVscGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG5leHBvcnQgKiBmcm9tICcuL2NydWQtaGVscGVycy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2FjY2Vzcy1oZWxwZXJzLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vc3NlLWhlbHBlcnMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9vcmctaGllcmFyY2h5LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vb3JnLWhpZXJhcmNoeS1odHRwLmpzJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaGVscGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbmV4cG9ydCAqIGZyb20gJy4vY3J1ZC1oZWxwZXJzLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vYWNjZXNzLWhlbHBlcnMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9yZXN0b3JlLWhlbHBlcnMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9zc2UtaGVscGVycy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL29yZy1oaWVyYXJjaHkuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9vcmctaGllcmFyY2h5LWh0dHAuanMnO1xuIl19

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

@@ -0,0 +1,25 @@
+import type { Request, Response } from 'express';
+import type { Permission } from '../types/permissions.js';
+/** Minimal shape a restore route needs from the entity it restores. */
+export interface RestorableEntity {
+    orgId: string;
+    accessModifier?: string;
+}
+/** The slice of a service a restore route uses (satisfied by any CrudService). */
+export interface RestorableService<T extends RestorableEntity> {
+    findDeletedById(id: string, orgId?: string): Promise<T | null>;
+    restore(id: string, orgId: string, userId: string): Promise<T | null>;
+}
+/**
+ * Shared skeleton for a step-up-gated entity restore route: extract `:id`, load
+ * the own-org tombstone, gate a PUBLIC entity on `publishPermission` (parity with
+ * delete), restore, and 404 on miss. Returns `{ existing, restored }` on success,
+ * or `null` when it has ALREADY sent a response (400/404/403) — the caller then
+ * does the entity-specific audit + response. DRYs the near-identical
+ * pipeline / plugin / pipeline_template restore routes (which differ only in
+ * service, audit action, and response shaping).
+ */
+export declare function loadAndRestore<T extends RestorableEntity>(req: Request, res: Response, orgId: string, userId: string, service: RestorableService<T>, label: string, publishPermission: Permission): Promise<{
+    existing: T;
+    restored: T;
+} | null>;

package/lib/helpers/restore-helpers.js

@@ -0,0 +1,39 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { requirePublicAccess } from './access-helpers.js';
+import { sendEntityNotFound } from './crud-helpers.js';
+import { ErrorCode } from '../types/error-codes.js';
+import { getParam } from '../utils/params.js';
+import { sendBadRequest } from '../utils/response.js';
+/**
+ * Shared skeleton for a step-up-gated entity restore route: extract `:id`, load
+ * the own-org tombstone, gate a PUBLIC entity on `publishPermission` (parity with
+ * delete), restore, and 404 on miss. Returns `{ existing, restored }` on success,
+ * or `null` when it has ALREADY sent a response (400/404/403) — the caller then
+ * does the entity-specific audit + response. DRYs the near-identical
+ * pipeline / plugin / pipeline_template restore routes (which differ only in
+ * service, audit action, and response shaping).
+ */
+export async function loadAndRestore(req, res, orgId, userId, service, label, publishPermission) {
+    const id = getParam(req.params, 'id');
+    if (!id) {
+        sendBadRequest(res, `${label} ID is required.`, ErrorCode.MISSING_REQUIRED_FIELD);
+        return null;
+    }
+    // Load the TOMBSTONE (own-org). A live row / unknown id / already-purged → 404.
+    const existing = await service.findDeletedById(id, orgId);
+    if (!existing) {
+        sendEntityNotFound(res, label);
+        return null;
+    }
+    // Public (shared) entities: same publish gate as delete.
+    if (!requirePublicAccess(req, res, existing, publishPermission))
+        return null;
+    const restored = await service.restore(id, orgId, userId || 'system');
+    if (!restored) {
+        sendEntityNotFound(res, label);
+        return null;
+    }
+    return { existing, restored };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/middleware/step-up.js

@@ -40,8 +40,11 @@ export function verifyStepUpToken(token) {
 }
 // -- 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 (best-effort per-process). A step-up
-// token is 60s-lived, so the fallback window is tiny.
+// 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) {
@@ -66,17 +69,14 @@ export async function consumeStepUpJti(jti, expEpochSeconds) {
     const ttlSeconds = Math.max(1, expEpochSeconds - Math.floor(Date.now() / 1000));
     const client = redis();
     if (client) {
-        try {
-            // SET key value NX EX ttl → 'OK' when newly set, null when it already exists.
-            const res = await client.set(`stepup:jti:${jti}`, '1', 'EX', ttlSeconds, 'NX');
-            return res === 'OK';
-        }
-        catch (err) {
-            // Redis blip: fall through to the local guard (fail-safe = reject replays
-            // we CAN see; a cross-instance replay during an outage is a tolerated edge).
-            logger.warn('Step-up jti Redis consume failed; using local guard', { error: String(err) });
-        }
+        // 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);
@@ -122,4 +122,4 @@ export async function requireStepUp(req, res, next) {
     }
     next();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-up.js","sourceRoot":"","sources":["../../src/middleware/step-up.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAoBtC,OAAO,GAAG,MAAM,cAAc,CAAC;AAC/B,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,MAAM,MAAM,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;AACvC,MAAM,MAAM,GAAG,iBAAiB,CAAC;AAWjC,SAAS,YAAY;IACnB,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,OAAO,CAAkB,CAAC;AACjE,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAa;IAC7C,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC;IACtC,IAAI,CAAC,MAAM;QAAE,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;IAC5E,MAAM,IAAI,GAAsB,EAAE,UAAU,EAAE,CAAC,YAAY,EAAE,CAAC,EAAE,CAAC;IAEjE,IAAI,OAA2B,CAAC;IAChC,IAAI,CAAC;QACH,OAAO,GAAG,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAuB,CAAC;IAClE,CAAC;IAAC,OAAO,UAAU,EAAE,CAAC;QACpB,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC;QACjD,IAAI,CAAC,QAAQ;YAAE,MAAM,UAAU,CAAC;QAChC,OAAO,GAAG,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAuB,CAAC;IACpE,CAAC;IAED,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC;QAC/D,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;IAC3C,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,gFAAgF;AAChF,+EAA+E;AAC/E,gFAAgF;AAChF,sDAAsD;AAEtD,IAAI,MAA4E,CAAC;AACjF,SAAS,KAAK;IACZ,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,MAAM,GAAG,oBAAoB,CAAoD,aAAa,CAAC,CAAC;IAClG,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC,CAAC,yBAAyB;AACnE,MAAM,QAAQ,GAAG,WAAW,CAAC,GAAG,EAAE;IAChC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACvB,KAAK,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,MAAM;QAAE,IAAI,GAAG,IAAI,GAAG;YAAE,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AACtE,CAAC,EAAE,MAAM,CAAC,CAAC;AACX,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC;AAEnB;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,GAAW,EAAE,eAAuB;IACzE,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC;IAChF,MAAM,MAAM,GAAG,KAAK,EAAE,CAAC;IACvB,IAAI,MAAM,EAAE,CAAC;QACX,IAAI,CAAC;YACH,8EAA8E;YAC9E,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,GAAG,CAAC,cAAc,GAAG,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;YAC/E,OAAO,GAAG,KAAK,IAAI,CAAC;QACtB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,0EAA0E;YAC1E,6EAA6E;YAC7E,MAAM,CAAC,IAAI,CAAC,qDAAqD,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAC7F,CAAC;IACH,CAAC;IACD,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC;QAAE,OAAO,KAAK,CAAC;IAClC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,UAAU,GAAG,IAAI,CAAC,CAAC;IAChD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB;IACjF,MAAM,SAAS,GAAI,GAA6C,CAAC,IAAI,EAAE,GAAG,CAAC;IAC3E,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,yBAAyB,EAAE,cAAc,CAAC,CAAC;QAC/D,OAAO;IACT,CAAC;IAED,MAAM,KAAK,GAAG,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;IACnD,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,+BAA+B,EAAE,kBAAkB,CAAC,CAAC;QACzE,OAAO;IACT,CAAC;IAED,IAAI,OAA2B,CAAC;IAChC,IAAI,CAAC;QACH,OAAO,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC;IACrC,CAAC;IAAC,MAAM,CAAC;QACP,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,kCAAkC,EAAE,iBAAiB,CAAC,CAAC;QAC3E,OAAO;IACT,CAAC;IAED,IAAI,OAAO,CAAC,GAAG,KAAK,SAAS,EAAE,CAAC;QAC9B,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,sCAAsC,EAAE,kBAAkB,CAAC,CAAC;QAChF,OAAO;IACT,CAAC;IAED,IAAI,CAAC;QACH,IAAI,CAAC,CAAC,MAAM,gBAAgB,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;YACxD,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,uCAAuC,EAAE,gBAAgB,CAAC,CAAC;YAC/E,OAAO;QACT,CAAC;IACH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,KAAK,CAAC,6BAA6B,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACpE,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,6BAA6B,EAAE,iBAAiB,CAAC,CAAC;QACtE,OAAO;IACT,CAAC;IAED,IAAI,EAAE,CAAC;AACT,CAAC","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 { 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 (best-effort per-process). A step-up\n// token is 60s-lived, so the fallback window is tiny.\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    try {\n      // SET key value NX EX ttl → 'OK' when newly set, null when it already exists.\n      const res = await client.set(`stepup:jti:${jti}`, '1', 'EX', ttlSeconds, 'NX');\n      return res === 'OK';\n    } catch (err) {\n      // Redis blip: fall through to the local guard (fail-safe = reject replays\n      // we CAN see; a cross-instance replay during an outage is a tolerated edge).\n      logger.warn('Step-up jti Redis consume failed; using local guard', { error: String(err) });\n    }\n  }\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  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"]}
+//# 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 { 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  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/package.json

@@ -87,7 +87,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "3.4.109",
+  "version": "3.4.110",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },