@pipeline-builder/api-core 3.4.108 → 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/index.d.ts

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

package/lib/middleware/index.js

@@ -2,4 +2,5 @@
 // SPDX-License-Identifier: Apache-2.0
 export * from './auth.js';
 export * from './mongo-sanitize.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWlkZGxld2FyZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMscUJBQXFCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuZXhwb3J0ICogZnJvbSAnLi9hdXRoLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vbW9uZ28tc2FuaXRpemUuanMnO1xuIl19
+export * from './step-up.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWlkZGxld2FyZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuZXhwb3J0ICogZnJvbSAnLi9hdXRoLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vbW9uZ28tc2FuaXRpemUuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9zdGVwLXVwLmpzJztcbiJdfQ==

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,125 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import jwt from 'jsonwebtoken';
+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) {
+    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 { 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/lib/services/remote-audit-client.d.ts

@@ -10,7 +10,7 @@ import { type AuditSpool } from './audit-spool.js';
  * (`admin.superadmin.grant`, `org.ownership.transfer`, `user.login`, …). Keep
  * this list free of any platform-only action.
  */
-export declare const REMOTE_AUDIT_ACTIONS: readonly ['plugin.build.completed', 'plugin.build.failed', 'plugin.build.timeout', 'plugin.delete', 'plugin.upload', 'plugin.deploy', 'plugin.bulk.update', 'plugin.bulk.delete', 'plugin.dlq.purge', 'pipeline.create', 'pipeline.update', 'pipeline.delete', 'pipeline_template.create', 'pipeline_template.update', 'pipeline_template.delete', 'pipeline.execution.start', 'pipeline.execution.cancel', 'pipeline.registry.register', 'pipeline.registry.deregister', 'quota.reset', 'quota.limit.update', 'quota.delete', 'compliance.exemption.approve', 'compliance.exemption.revoke', 'compliance.rule.toggle', 'compliance.rule.create', 'compliance.rule.update', 'compliance.rule.delete', 'compliance.policy.create', 'compliance.policy.update', 'compliance.policy.delete', 'compliance.scan-schedule.create', 'compliance.scan-schedule.update', 'compliance.scan-schedule.delete', 'compliance.template.apply', 'compliance.scan.cancel', 'registry.gc', 'registry.image.delete', 'registry.image.copy', 'message.announcement.create', 'message.delete', 'billing.subscription.cancel', 'billing.subscription.delete', 'billing.tier.override', 'billing.addon.add', 'billing.addon.remove', 'billing.addon.prune', 'billing.discount.generate', 'billing.discount.issue', 'billing.discount.apply', 'billing.discount.remove', 'billing.discount.revoke', 'billing.promotion.create', 'billing.promotion.update', 'billing.promotion.revoke', 'billing.promotion.grant', 'billing.promotion.activate', 'billing.credit.consumed', 'billing.credit.exhausted', 'billing.combo.expired', 'authz.denied'];
+export declare const REMOTE_AUDIT_ACTIONS: readonly ['plugin.build.completed', 'plugin.build.failed', 'plugin.build.timeout', 'plugin.delete', 'plugin.restore', 'plugin.upload', 'plugin.deploy', 'plugin.bulk.update', 'plugin.bulk.delete', 'plugin.dlq.purge', 'pipeline.create', 'pipeline.update', 'pipeline.delete', 'pipeline.restore', 'pipeline_template.create', 'pipeline_template.update', 'pipeline_template.delete', 'pipeline_template.restore', 'pipeline.execution.start', 'pipeline.execution.cancel', 'pipeline.registry.register', 'pipeline.registry.deregister', 'quota.reset', 'quota.limit.update', 'quota.delete', 'compliance.exemption.approve', 'compliance.exemption.revoke', 'compliance.rule.toggle', 'compliance.rule.create', 'compliance.rule.update', 'compliance.rule.delete', 'compliance.rule.restore', 'compliance.policy.create', 'compliance.policy.update', 'compliance.policy.delete', 'compliance.policy.restore', 'compliance.scan-schedule.create', 'compliance.scan-schedule.update', 'compliance.scan-schedule.delete', 'compliance.template.apply', 'compliance.scan.cancel', 'registry.gc', 'registry.image.delete', 'registry.image.copy', 'message.announcement.create', 'message.delete', 'message.restore', 'billing.subscription.cancel', 'billing.subscription.delete', 'billing.tier.override', 'billing.addon.add', 'billing.addon.remove', 'billing.addon.prune', 'billing.discount.generate', 'billing.discount.issue', 'billing.discount.apply', 'billing.discount.remove', 'billing.discount.revoke', 'billing.promotion.create', 'billing.promotion.update', 'billing.promotion.revoke', 'billing.promotion.grant', 'billing.promotion.activate', 'billing.credit.consumed', 'billing.credit.exhausted', 'billing.combo.expired', 'authz.denied'];
 export type RemoteAuditAction = typeof REMOTE_AUDIT_ACTIONS[number];
 /** Whether `value` is an action a remote service may emit (the ingest allow-list). */
 export declare function isRemoteAuditAction(value: string): value is RemoteAuditAction;

package/lib/services/remote-audit-client.js

@@ -39,6 +39,7 @@ export const REMOTE_AUDIT_ACTIONS = [
     // publishing surface that builds already audit's counterpart: registry delete,
     // source upload, and deploy-to-cluster. `targetId` is the plugin id.
     'plugin.delete',
+    'plugin.restore',
     'plugin.upload',
     'plugin.deploy',
     // Plugin bulk mutations (api/plugin bulk-plugin route) + DLQ purge (drops all
@@ -52,9 +53,11 @@ export const REMOTE_AUDIT_ACTIONS = [
     'pipeline.create',
     'pipeline.update',
     'pipeline.delete',
+    'pipeline.restore',
     'pipeline_template.create',
     'pipeline_template.update',
     'pipeline_template.delete',
+    'pipeline_template.restore',
     'pipeline.execution.start',
     'pipeline.execution.cancel',
     // CodePipeline ARN-registry config (api/pipeline registry route) — registering /
@@ -78,9 +81,11 @@ export const REMOTE_AUDIT_ACTIONS = [
     'compliance.rule.create',
     'compliance.rule.update',
     'compliance.rule.delete',
+    'compliance.rule.restore',
     'compliance.policy.create',
     'compliance.policy.update',
     'compliance.policy.delete',
+    'compliance.policy.restore',
     'compliance.scan-schedule.create',
     'compliance.scan-schedule.update',
     'compliance.scan-schedule.delete',
@@ -100,6 +105,7 @@ export const REMOTE_AUDIT_ACTIONS = [
     // (subject/type/scope), NEVER message body content.
     'message.announcement.create',
     'message.delete',
+    'message.restore',
     // Billing (api/billing) — subscription + entitlement mutations, mirrored to the
     // central audit trail (these also write to the service-local billing_events
     // collection). `details` carry plan/tier/addon ids only — never card/payment
@@ -357,4 +363,4 @@ export function createRemoteAuditAccessor(serviceName) {
         emit: (event) => svc().emit(event),
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remote-audit-client.js","sourceRoot":"","sources":["../../src/services/remote-audit-client.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { randomUUID } from 'crypto';\nimport { createEnvRedisAuditSpool, type AuditSpool, type AuditSpoolEntry } from './audit-spool.js';\nimport { createSafeClient, type RequestOptions } from './http-client.js';\nimport { getServiceAuthHeader, setAuthzDenialAuditor, type AuthzDenialInfo } from '../middleware/auth.js';\nimport type { ServiceConfig } from '../types/common.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('remote-audit');\n\n/**\n * Audit ingest is best-effort and MUST NOT block the caller, but a transient\n * failure (429 / 5xx / connection reset / timeout) should not silently drop the\n * row on the first attempt. Each emission carries a stable per-event\n * `Idempotency-Key` (see `record`), so the http-client treats the POST as\n * retry-safe and the platform can dedup a retried delivery instead of writing a\n * duplicate row. Budget is kept small so a hard-down platform can't back the\n * worker up for long: base delay ×(2 retries) + a couple of 429 backoffs.\n */\nconst AUDIT_REQUEST_OPTIONS: Pick<RequestOptions, 'maxRateLimitRetries' | 'maxRetries'> = {\n  maxRateLimitRetries: 2,\n  maxRetries: 2,\n};\n\n/**\n * The exact set of audit actions a NON-PLATFORM (remote) service is permitted to\n * emit through `POST /audit/events`. This is the SINGLE SOURCE — `RemoteAuditAction`\n * is derived from it, so the type and the runtime allow-list can never drift.\n *\n * SECURITY: platform's ingest validates `action` against this subset (via\n * {@link isRemoteAuditAction}), NOT the full platform `AuditAction` union — a\n * `service:*` token must not be able to forge platform-authority events\n * (`admin.superadmin.grant`, `org.ownership.transfer`, `user.login`, …). Keep\n * this list free of any platform-only action.\n */\nexport const REMOTE_AUDIT_ACTIONS = [\n  'plugin.build.completed',\n  'plugin.build.failed',\n  'plugin.build.timeout',\n  // Plugin lifecycle mutations (api/plugin route handlers) — the destructive /\n  // publishing surface that builds already audit's counterpart: registry delete,\n  // source upload, and deploy-to-cluster. `targetId` is the plugin id.\n  'plugin.delete',\n  'plugin.upload',\n  'plugin.deploy',\n  // Plugin bulk mutations (api/plugin bulk-plugin route) + DLQ purge (drops all\n  // dead-lettered build jobs, cross-org, sysadmin). `details` carries counts.\n  'plugin.bulk.update',\n  'plugin.bulk.delete',\n  'plugin.dlq.purge',\n  // Pipeline mutations — emitted by api/pipeline's route handlers\n  // (create/update/delete + CodePipeline execution trigger/cancel) and\n  // posted to platform's `POST /audit/events` ingest.\n  'pipeline.create',\n  'pipeline.update',\n  'pipeline.delete',\n  'pipeline_template.create',\n  'pipeline_template.update',\n  'pipeline_template.delete',\n  'pipeline.execution.start',\n  'pipeline.execution.cancel',\n  // CodePipeline ARN-registry config (api/pipeline registry route) — registering /\n  // deregistering the external CodePipeline that backs a pipeline (deploy-affecting).\n  'pipeline.registry.register',\n  'pipeline.registry.deregister',\n  // Quota administration (api/quota) — a superadmin resetting an org's usage\n  // counter or editing its tier limits. `affectedOrgId` is the org changed;\n  // `details` carries the quotaType + old/new value.\n  'quota.reset',\n  'quota.limit.update',\n  // A superadmin deleting an org's entire quota document.\n  'quota.delete',\n  // Compliance administration (api/compliance) — the enforcement-posture surface.\n  // Approving/revoking an exemption, toggling/authoring/deleting a rule,\n  // authoring/deleting a policy, managing scan schedules, applying a template,\n  // or cancelling a running scan. `targetId` is the rule/policy/exemption/scan id.\n  'compliance.exemption.approve',\n  'compliance.exemption.revoke',\n  'compliance.rule.toggle',\n  'compliance.rule.create',\n  'compliance.rule.update',\n  'compliance.rule.delete',\n  'compliance.policy.create',\n  'compliance.policy.update',\n  'compliance.policy.delete',\n  'compliance.scan-schedule.create',\n  'compliance.scan-schedule.update',\n  'compliance.scan-schedule.delete',\n  'compliance.template.apply',\n  'compliance.scan.cancel',\n  // Image-registry destructive ops (api/image-registry) — garbage-collection\n  // sweeps and explicit image/tag deletes (previously only a log line).\n  'registry.gc',\n  'registry.image.delete',\n  // Cross-repo tag/image copy (api/image-registry POST /api/images/copy). A\n  // cross-tenant copy moves data across customer boundaries, so it needs the\n  // durable, tamper-evident trail — not just the Loki operator line.\n  'registry.image.copy',\n  // Messaging (api/message) — admin BROADCAST announcements + destructive\n  // deletes. 1:1 user messages are intentionally NOT audited (noise + they would\n  // pull private content into the trail). `details` carry metadata only\n  // (subject/type/scope), NEVER message body content.\n  'message.announcement.create',\n  'message.delete',\n  // Billing (api/billing) — subscription + entitlement mutations, mirrored to the\n  // central audit trail (these also write to the service-local billing_events\n  // collection). `details` carry plan/tier/addon ids only — never card/payment\n  // secrets or an AWS account id.\n  'billing.subscription.cancel',\n  'billing.subscription.delete',\n  'billing.tier.override',\n  'billing.addon.add',\n  'billing.addon.remove',\n  // System-initiated removal of a tier-included add-on on a plan upgrade (the\n  // account's new tier now bundles the feature) — distinct from a user-initiated\n  // `remove` so finance can tell an auto-prune from a customer action.\n  'billing.addon.prune',\n  // Discounts (docs/billing-discounts.md) — mint/issue/apply/remove/revoke of a\n  // price coupon or usage credit. `details` carry the discount id + kind/value\n  // only, never the opaque token or signing key.\n  'billing.discount.generate',\n  'billing.discount.issue',\n  'billing.discount.apply',\n  'billing.discount.remove',\n  'billing.discount.revoke',\n  // Promotions (docs/billing-discounts.md#promotions) — rule-driven auto-grant\n  // campaigns. `details` carry the promotion id + cents/event only.\n  'billing.promotion.create',\n  'billing.promotion.update',\n  'billing.promotion.revoke',\n  'billing.promotion.grant',\n  'billing.promotion.activate',\n  // Usage-credit realization — a customer/compliance-visible record of credit\n  // movement: `consumed` (Marketplace metered drawdown), `exhausted` (balance hit\n  // zero), and a combo ending. `details` carry cents/ids only, no payment secrets.\n  'billing.credit.consumed',\n  'billing.credit.exhausted',\n  'billing.combo.expired',\n  // Denied authorization attempt — emitted best-effort by the shared\n  // `requirePermission` / `requireSystemAdmin` gate when a state-changing\n  // (non-GET) request is rejected, so probing/escalation attempts are visible\n  // rather than invisible. `details` carries the required permission + path;\n  // `outcome` is 'failure'.\n  'authz.denied',\n] as const;\n\nexport type RemoteAuditAction = typeof REMOTE_AUDIT_ACTIONS[number];\n\n/** Whether `value` is an action a remote service may emit (the ingest allow-list). */\nexport function isRemoteAuditAction(value: string): value is RemoteAuditAction {\n  return (REMOTE_AUDIT_ACTIONS as readonly string[]).includes(value);\n}\n\nexport interface RemoteAuditEvent {\n  action: RemoteAuditAction;\n  actorId: string;\n  actorEmail?: string;\n  orgId?: string;\n  affectedOrgId?: string;\n  targetType?: string;\n  targetId?: string;\n  /**\n   * Did the audited action succeed or fail? Defaults to 'success' when omitted\n   * (the platform ingest applies the same default). Denied-authz events set\n   * 'failure' so a reviewer can filter attempts from completed actions.\n   */\n  outcome?: 'success' | 'failure';\n  /**\n   * When the audited action actually OCCURRED (ISO-8601), stamped at emission.\n   * The platform stores this for reviewers; it is NOT the chain-ordering field\n   * (the tamper-evident chain orders by ingest/`createdAt`). It matters for\n   * SPOOLED events: one buffered during a platform outage is re-delivered — and\n   * so chained — later, but `occurredAt` preserves when it really happened.\n   */\n  occurredAt?: string;\n  /**\n   * Stable per-emission dedup key (also sent as the `Idempotency-Key` header the\n   * platform ingest dedups on). Stamped by `record()` and carried on the spooled\n   * copy so a live attempt and its later re-delivery collapse to ONE stored row.\n   */\n  idempotencyKey?: string;\n  details?: Record<string, unknown>;\n}\n\n/**\n * Client for POSTing audit events to the platform's `/audit-events` ingest\n * endpoint. Mints a fresh service token per call (5 min TTL)  there's no\n * meaningful caching benefit when emissions are sparse.\n */\nexport interface RemoteAuditClient {\n  /**\n   * Fire-and-forget audit emission. Failures are logged at warn level but\n   * never thrown  the originating action (e.g. a plugin build) has its\n   * own success/failure path that shouldn't get polluted by a flaky audit\n   * downstream. When a {@link AuditSpool} is configured, an emission that\n   * exhausts its live retries is buffered and re-delivered later instead of\n   * being dropped.\n   */\n  record(event: RemoteAuditEvent, serviceName: string): void;\n  /** Stop the background spool-drain timer (if any). Safe to call repeatedly. */\n  close(): void;\n}\n\n/**\n * Configuration for the remote audit client.\n */\nexport interface RemoteAuditClientConfig {\n  /** Platform service host (default: env PLATFORM_SERVICE_HOST or 'platform') */\n  host?: string;\n  /** Platform service port (default: env PLATFORM_SERVICE_PORT or 3000) */\n  port?: number;\n  /** Request timeout ms (default 3000  audit shouldn't block the worker). */\n  timeout?: number;\n  /**\n   * Optional durable buffer. When set, an emission that exhausts its live retry\n   * budget (sustained platform outage) is spooled and re-delivered — on the next\n   * successful emission and on a periodic timer — instead of being lost.\n   */\n  spool?: AuditSpool;\n  /** Spool-drain interval ms (default 30_000). Only used when `spool` is set. */\n  drainIntervalMs?: number;\n  /** Max entries drained per sweep (default 100). */\n  drainBatchSize?: number;\n}\n\n/**\n * Construct a remote-audit client targeted at the platform service.\n *\n * Used by api/plugin's build worker to push `plugin.build.*` events into\n * the platform's MongoDB `audit_events` collection. Other services\n * with worker-style emitters can use the same client.\n *\n * @example\n * ```typescript\n * const auditClient = createRemoteAuditClient();\n * auditClient.record({\n * action: 'plugin.build.completed',\n * actorId: 'user-123',\n * orgId: 'org-acme',\n * targetType: 'plugin',\n * targetId: 'plugin-abc',\n * details: { name: 'my-plugin', version: '1.0.0' },\n * }, 'plugin');\n * ```\n */\nexport function createRemoteAuditClient(config: RemoteAuditClientConfig = {}): RemoteAuditClient {\n  const serviceConfig: ServiceConfig = {\n    host: config.host ?? process.env.PLATFORM_SERVICE_HOST ?? 'platform',\n    port: config.port ?? parseInt(process.env.PLATFORM_SERVICE_PORT ?? '3000', 10),\n    timeout: config.timeout ?? 3000,\n  };\n  const client = createSafeClient(serviceConfig);\n  const spool = config.spool;\n  const drainBatchSize = config.drainBatchSize ?? 100;\n\n  /**\n   * Attempt ONE live delivery. Resolves `true` on a 2xx accept, `false` on any\n   * non-2xx / thrown error (the http-client has already applied the retry\n   * budget). A stable per-emission `Idempotency-Key` makes this non-idempotent\n   * POST retry-safe and lets the platform ingest dedup a re-delivered event\n   * instead of writing a duplicate audit row (and duplicate chain link).\n   * `Idempotency-Key` is derived from the event so a SPOOLED re-delivery reuses\n   * the same key as its original live attempt — the two collapse to one row.\n   */\n  async function deliver(event: RemoteAuditEvent, serviceName: string): Promise<boolean> {\n    const authHeader = getServiceAuthHeader({ serviceName, orgId: event.orgId, role: 'member' });\n    const headers: Record<string, string> = {\n      'Authorization': authHeader,\n      'Idempotency-Key': event.idempotencyKey ?? randomUUID(),\n    };\n    try {\n      const response = await client.post('/audit/events', event, { headers, ...AUDIT_REQUEST_OPTIONS });\n      const ok = !!response && response.statusCode >= 200 && response.statusCode < 300;\n      if (!ok) {\n        logger.warn('Remote audit ingest non-ok', { action: event.action, statusCode: response?.statusCode });\n      }\n      return ok;\n    } catch (err) {\n      logger.warn('Remote audit ingest threw', { action: event.action, error: err instanceof Error ? err.message : String(err) });\n      return false;\n    }\n  }\n\n  // Serialize spool drains so a periodic tick and an on-success drain can't both\n  // pull the same batch. Stops early the moment a re-delivery fails (platform\n  // still down) so we don't hammer it or churn the buffer.\n  let draining = false;\n  async function drain(): Promise<void> {\n    if (!spool || draining) return;\n    draining = true;\n    try {\n      for (;;) {\n        const batch = await spool.take(drainBatchSize);\n        if (batch.length === 0) return;\n        const delivered: AuditSpoolEntry[] = [];\n        const failed: AuditSpoolEntry[] = [];\n        let platformDown = false;\n        for (const entry of batch) {\n          if (platformDown) { failed.push(entry); continue; }\n          const ok = await deliver(entry.event, entry.serviceName);\n          if (ok) {\n            delivered.push(entry);\n            emitCounter('audit_spool_redelivered_total', { service: entry.serviceName });\n          } else {\n            platformDown = true;\n            failed.push(entry);\n          }\n        }\n        // Acknowledge the delivered prefix so it clears the in-progress list; the\n        // reliable take() moved the whole batch there, so unacked survivors are\n        // reclaimed by recover() after a crash rather than being silently lost.\n        if (delivered.length > 0) await spool.ack(delivered);\n        if (failed.length > 0) {\n          await spool.requeue(failed);\n          return; // still down — try again on the next tick\n        }\n      }\n    } catch (err) {\n      logger.warn('Audit spool drain failed', { error: err instanceof Error ? err.message : String(err) });\n    } finally {\n      draining = false;\n    }\n  }\n\n  let drainTimer: ReturnType<typeof setInterval> | undefined;\n  if (spool) {\n    // Reclaim any batch stranded on the in-progress list by a prior crash, then\n    // attempt to flush it. Both are best-effort (the spool swallows its errors).\n    void spool.recover().then(() => drain());\n    drainTimer = setInterval(() => { void drain(); }, config.drainIntervalMs ?? 30_000);\n    // Don't let the drain timer keep the process alive on shutdown.\n    (drainTimer as unknown as { unref?: () => void }).unref?.();\n  }\n\n  return {\n    record(event, serviceName) {\n      // Stamp when the action actually occurred (survives spool delay) and pin a\n      // stable idempotency key so a live attempt and its spooled retry dedup.\n      const stamped: RemoteAuditEvent = {\n        ...event,\n        occurredAt: event.occurredAt ?? new Date().toISOString(),\n        idempotencyKey: event.idempotencyKey ?? randomUUID(),\n      };\n      void deliver(stamped, serviceName).then((ok) => {\n        if (ok) {\n          emitCounter('audit_emitted_total', { service: serviceName, outcome: stamped.outcome ?? 'success' });\n          if (spool) void drain(); // platform is reachable — flush any backlog\n        } else if (spool) {\n          void spool.enqueue({ event: stamped, serviceName });\n        } else {\n          emitCounter('audit_dropped_total', { service: serviceName });\n        }\n      });\n    },\n    close() {\n      if (drainTimer) { clearInterval(drainTimer); drainTimer = undefined; }\n    },\n  };\n}\n\n/**\n * Register the standard `authz.denied` sink used by every remote-audit service\n * (pipeline, plugin, compliance, quota, message, billing, reporting, …).\n *\n * The shared `requireAuth` gate forwards each DENIED state-changing request to\n * the auditor set via {@link setAuthzDenialAuditor}; this wires that hook to the\n * service's {@link RemoteAuditClient}, forwarding a `failure`-outcome\n * `authz.denied` event so probing / privilege-escalation attempts leave a trail.\n * Emission is fire-and-forget (the client never throws). `getClient` is a getter\n * so the client stays lazily constructed (services memoize it on first use).\n *\n * Platform is intentionally NOT a caller — it is the audit authority and writes\n * `authz.denied` straight to its local store (with `affectedOrgId`), not through\n * a RemoteAuditClient.\n */\nexport function wireAuthzDenialAuditor(serviceName: string, getClient: () => RemoteAuditClient): void {\n  setAuthzDenialAuditor((info: AuthzDenialInfo) => getClient().record({\n    action: 'authz.denied',\n    actorId: info.actorId ?? 'anonymous',\n    actorEmail: info.actorEmail,\n    orgId: info.orgId,\n    outcome: 'failure',\n    details: { method: info.method, path: info.path, required: info.required },\n  }, serviceName));\n}\n\n/**\n * A service-scoped audit client: a durable-spool-backed {@link RemoteAuditClient}\n * with the service name pre-bound for emission. Replaces the per-service\n * boilerplate of `createRemoteAuditClient({ spool: createEnvRedisAuditSpool() ?? undefined })`\n * plus a hand-rolled `emit<Service>Audit` wrapper that repeats the service name.\n */\nexport interface ServiceAuditClient {\n  /** Emit an audit event with the service name bound. Fire-and-forget. */\n  emit(event: RemoteAuditEvent): void;\n  /** The underlying remote client — for `wireAuthzDenialAuditor` + `close()`. */\n  readonly client: RemoteAuditClient;\n}\n\n/**\n * Build a service's audit client: a RemoteAuditClient wired to the durable Redis\n * spool (from ambient env; null → no spool) with `serviceName` bound. Construct\n * ONCE per process — memoize behind a lazy `getAuditClient()` in the service's\n * `services/audit.ts`. Pass `config.spool` to override the env-derived spool\n * (e.g. reuse a service's existing ioredis connection).\n */\nexport function createServiceAuditClient(serviceName: string, config: RemoteAuditClientConfig = {}): ServiceAuditClient {\n  const spool = config.spool ?? createEnvRedisAuditSpool() ?? undefined;\n  const client = createRemoteAuditClient({ ...config, spool });\n  return {\n    emit: (event) => client.record(event, serviceName),\n    client,\n  };\n}\n\n/**\n * Lazily-constructed remote-audit accessor for a service. Every service's\n * `services/audit.ts` used to hand-roll the same module singleton (a `let audit`\n * + `svc()` that builds a {@link ServiceAuditClient} on first use, then a\n * `getAuditClient()` returning `.client` and an `emit(event)` forwarding to\n * `.emit`). This packages that pattern in ONE place so each service's audit\n * wiring is a one-liner and can't drift.\n *\n * Lazy on purpose: the underlying client wires an env-Redis audit spool, so\n * building it at import time would force that connection wherever the module is\n * merely imported (e.g. tests). `getAuditClient` is passed to\n * `wireAuthzDenialAuditor`; `emit` backs the per-service `emitXAudit` helpers.\n * Both stay FIRE-AND-FORGET (record never throws / is not awaited).\n */\nexport function createRemoteAuditAccessor(serviceName: string): {\n  getAuditClient: () => RemoteAuditClient;\n  emit: (event: RemoteAuditEvent) => void;\n} {\n  let audit: ServiceAuditClient | null = null;\n  const svc = (): ServiceAuditClient => {\n    if (!audit) audit = createServiceAuditClient(serviceName);\n    return audit;\n  };\n  return {\n    getAuditClient: () => svc().client,\n    emit: (event) => svc().emit(event),\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remote-audit-client.js","sourceRoot":"","sources":["../../src/services/remote-audit-client.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { randomUUID } from 'crypto';\nimport { createEnvRedisAuditSpool, type AuditSpool, type AuditSpoolEntry } from './audit-spool.js';\nimport { createSafeClient, type RequestOptions } from './http-client.js';\nimport { getServiceAuthHeader, setAuthzDenialAuditor, type AuthzDenialInfo } from '../middleware/auth.js';\nimport type { ServiceConfig } from '../types/common.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('remote-audit');\n\n/**\n * Audit ingest is best-effort and MUST NOT block the caller, but a transient\n * failure (429 / 5xx / connection reset / timeout) should not silently drop the\n * row on the first attempt. Each emission carries a stable per-event\n * `Idempotency-Key` (see `record`), so the http-client treats the POST as\n * retry-safe and the platform can dedup a retried delivery instead of writing a\n * duplicate row. Budget is kept small so a hard-down platform can't back the\n * worker up for long: base delay ×(2 retries) + a couple of 429 backoffs.\n */\nconst AUDIT_REQUEST_OPTIONS: Pick<RequestOptions, 'maxRateLimitRetries' | 'maxRetries'> = {\n  maxRateLimitRetries: 2,\n  maxRetries: 2,\n};\n\n/**\n * The exact set of audit actions a NON-PLATFORM (remote) service is permitted to\n * emit through `POST /audit/events`. This is the SINGLE SOURCE — `RemoteAuditAction`\n * is derived from it, so the type and the runtime allow-list can never drift.\n *\n * SECURITY: platform's ingest validates `action` against this subset (via\n * {@link isRemoteAuditAction}), NOT the full platform `AuditAction` union — a\n * `service:*` token must not be able to forge platform-authority events\n * (`admin.superadmin.grant`, `org.ownership.transfer`, `user.login`, …). Keep\n * this list free of any platform-only action.\n */\nexport const REMOTE_AUDIT_ACTIONS = [\n  'plugin.build.completed',\n  'plugin.build.failed',\n  'plugin.build.timeout',\n  // Plugin lifecycle mutations (api/plugin route handlers) — the destructive /\n  // publishing surface that builds already audit's counterpart: registry delete,\n  // source upload, and deploy-to-cluster. `targetId` is the plugin id.\n  'plugin.delete',\n  'plugin.restore',\n  'plugin.upload',\n  'plugin.deploy',\n  // Plugin bulk mutations (api/plugin bulk-plugin route) + DLQ purge (drops all\n  // dead-lettered build jobs, cross-org, sysadmin). `details` carries counts.\n  'plugin.bulk.update',\n  'plugin.bulk.delete',\n  'plugin.dlq.purge',\n  // Pipeline mutations — emitted by api/pipeline's route handlers\n  // (create/update/delete + CodePipeline execution trigger/cancel) and\n  // posted to platform's `POST /audit/events` ingest.\n  'pipeline.create',\n  'pipeline.update',\n  'pipeline.delete',\n  'pipeline.restore',\n  'pipeline_template.create',\n  'pipeline_template.update',\n  'pipeline_template.delete',\n  'pipeline_template.restore',\n  'pipeline.execution.start',\n  'pipeline.execution.cancel',\n  // CodePipeline ARN-registry config (api/pipeline registry route) — registering /\n  // deregistering the external CodePipeline that backs a pipeline (deploy-affecting).\n  'pipeline.registry.register',\n  'pipeline.registry.deregister',\n  // Quota administration (api/quota) — a superadmin resetting an org's usage\n  // counter or editing its tier limits. `affectedOrgId` is the org changed;\n  // `details` carries the quotaType + old/new value.\n  'quota.reset',\n  'quota.limit.update',\n  // A superadmin deleting an org's entire quota document.\n  'quota.delete',\n  // Compliance administration (api/compliance) — the enforcement-posture surface.\n  // Approving/revoking an exemption, toggling/authoring/deleting a rule,\n  // authoring/deleting a policy, managing scan schedules, applying a template,\n  // or cancelling a running scan. `targetId` is the rule/policy/exemption/scan id.\n  'compliance.exemption.approve',\n  'compliance.exemption.revoke',\n  'compliance.rule.toggle',\n  'compliance.rule.create',\n  'compliance.rule.update',\n  'compliance.rule.delete',\n  'compliance.rule.restore',\n  'compliance.policy.create',\n  'compliance.policy.update',\n  'compliance.policy.delete',\n  'compliance.policy.restore',\n  'compliance.scan-schedule.create',\n  'compliance.scan-schedule.update',\n  'compliance.scan-schedule.delete',\n  'compliance.template.apply',\n  'compliance.scan.cancel',\n  // Image-registry destructive ops (api/image-registry) — garbage-collection\n  // sweeps and explicit image/tag deletes (previously only a log line).\n  'registry.gc',\n  'registry.image.delete',\n  // Cross-repo tag/image copy (api/image-registry POST /api/images/copy). A\n  // cross-tenant copy moves data across customer boundaries, so it needs the\n  // durable, tamper-evident trail — not just the Loki operator line.\n  'registry.image.copy',\n  // Messaging (api/message) — admin BROADCAST announcements + destructive\n  // deletes. 1:1 user messages are intentionally NOT audited (noise + they would\n  // pull private content into the trail). `details` carry metadata only\n  // (subject/type/scope), NEVER message body content.\n  'message.announcement.create',\n  'message.delete',\n  'message.restore',\n  // Billing (api/billing) — subscription + entitlement mutations, mirrored to the\n  // central audit trail (these also write to the service-local billing_events\n  // collection). `details` carry plan/tier/addon ids only — never card/payment\n  // secrets or an AWS account id.\n  'billing.subscription.cancel',\n  'billing.subscription.delete',\n  'billing.tier.override',\n  'billing.addon.add',\n  'billing.addon.remove',\n  // System-initiated removal of a tier-included add-on on a plan upgrade (the\n  // account's new tier now bundles the feature) — distinct from a user-initiated\n  // `remove` so finance can tell an auto-prune from a customer action.\n  'billing.addon.prune',\n  // Discounts (docs/billing-discounts.md) — mint/issue/apply/remove/revoke of a\n  // price coupon or usage credit. `details` carry the discount id + kind/value\n  // only, never the opaque token or signing key.\n  'billing.discount.generate',\n  'billing.discount.issue',\n  'billing.discount.apply',\n  'billing.discount.remove',\n  'billing.discount.revoke',\n  // Promotions (docs/billing-discounts.md#promotions) — rule-driven auto-grant\n  // campaigns. `details` carry the promotion id + cents/event only.\n  'billing.promotion.create',\n  'billing.promotion.update',\n  'billing.promotion.revoke',\n  'billing.promotion.grant',\n  'billing.promotion.activate',\n  // Usage-credit realization — a customer/compliance-visible record of credit\n  // movement: `consumed` (Marketplace metered drawdown), `exhausted` (balance hit\n  // zero), and a combo ending. `details` carry cents/ids only, no payment secrets.\n  'billing.credit.consumed',\n  'billing.credit.exhausted',\n  'billing.combo.expired',\n  // Denied authorization attempt — emitted best-effort by the shared\n  // `requirePermission` / `requireSystemAdmin` gate when a state-changing\n  // (non-GET) request is rejected, so probing/escalation attempts are visible\n  // rather than invisible. `details` carries the required permission + path;\n  // `outcome` is 'failure'.\n  'authz.denied',\n] as const;\n\nexport type RemoteAuditAction = typeof REMOTE_AUDIT_ACTIONS[number];\n\n/** Whether `value` is an action a remote service may emit (the ingest allow-list). */\nexport function isRemoteAuditAction(value: string): value is RemoteAuditAction {\n  return (REMOTE_AUDIT_ACTIONS as readonly string[]).includes(value);\n}\n\nexport interface RemoteAuditEvent {\n  action: RemoteAuditAction;\n  actorId: string;\n  actorEmail?: string;\n  orgId?: string;\n  affectedOrgId?: string;\n  targetType?: string;\n  targetId?: string;\n  /**\n   * Did the audited action succeed or fail? Defaults to 'success' when omitted\n   * (the platform ingest applies the same default). Denied-authz events set\n   * 'failure' so a reviewer can filter attempts from completed actions.\n   */\n  outcome?: 'success' | 'failure';\n  /**\n   * When the audited action actually OCCURRED (ISO-8601), stamped at emission.\n   * The platform stores this for reviewers; it is NOT the chain-ordering field\n   * (the tamper-evident chain orders by ingest/`createdAt`). It matters for\n   * SPOOLED events: one buffered during a platform outage is re-delivered — and\n   * so chained — later, but `occurredAt` preserves when it really happened.\n   */\n  occurredAt?: string;\n  /**\n   * Stable per-emission dedup key (also sent as the `Idempotency-Key` header the\n   * platform ingest dedups on). Stamped by `record()` and carried on the spooled\n   * copy so a live attempt and its later re-delivery collapse to ONE stored row.\n   */\n  idempotencyKey?: string;\n  details?: Record<string, unknown>;\n}\n\n/**\n * Client for POSTing audit events to the platform's `/audit-events` ingest\n * endpoint. Mints a fresh service token per call (5 min TTL)  there's no\n * meaningful caching benefit when emissions are sparse.\n */\nexport interface RemoteAuditClient {\n  /**\n   * Fire-and-forget audit emission. Failures are logged at warn level but\n   * never thrown  the originating action (e.g. a plugin build) has its\n   * own success/failure path that shouldn't get polluted by a flaky audit\n   * downstream. When a {@link AuditSpool} is configured, an emission that\n   * exhausts its live retries is buffered and re-delivered later instead of\n   * being dropped.\n   */\n  record(event: RemoteAuditEvent, serviceName: string): void;\n  /** Stop the background spool-drain timer (if any). Safe to call repeatedly. */\n  close(): void;\n}\n\n/**\n * Configuration for the remote audit client.\n */\nexport interface RemoteAuditClientConfig {\n  /** Platform service host (default: env PLATFORM_SERVICE_HOST or 'platform') */\n  host?: string;\n  /** Platform service port (default: env PLATFORM_SERVICE_PORT or 3000) */\n  port?: number;\n  /** Request timeout ms (default 3000  audit shouldn't block the worker). */\n  timeout?: number;\n  /**\n   * Optional durable buffer. When set, an emission that exhausts its live retry\n   * budget (sustained platform outage) is spooled and re-delivered — on the next\n   * successful emission and on a periodic timer — instead of being lost.\n   */\n  spool?: AuditSpool;\n  /** Spool-drain interval ms (default 30_000). Only used when `spool` is set. */\n  drainIntervalMs?: number;\n  /** Max entries drained per sweep (default 100). */\n  drainBatchSize?: number;\n}\n\n/**\n * Construct a remote-audit client targeted at the platform service.\n *\n * Used by api/plugin's build worker to push `plugin.build.*` events into\n * the platform's MongoDB `audit_events` collection. Other services\n * with worker-style emitters can use the same client.\n *\n * @example\n * ```typescript\n * const auditClient = createRemoteAuditClient();\n * auditClient.record({\n * action: 'plugin.build.completed',\n * actorId: 'user-123',\n * orgId: 'org-acme',\n * targetType: 'plugin',\n * targetId: 'plugin-abc',\n * details: { name: 'my-plugin', version: '1.0.0' },\n * }, 'plugin');\n * ```\n */\nexport function createRemoteAuditClient(config: RemoteAuditClientConfig = {}): RemoteAuditClient {\n  const serviceConfig: ServiceConfig = {\n    host: config.host ?? process.env.PLATFORM_SERVICE_HOST ?? 'platform',\n    port: config.port ?? parseInt(process.env.PLATFORM_SERVICE_PORT ?? '3000', 10),\n    timeout: config.timeout ?? 3000,\n  };\n  const client = createSafeClient(serviceConfig);\n  const spool = config.spool;\n  const drainBatchSize = config.drainBatchSize ?? 100;\n\n  /**\n   * Attempt ONE live delivery. Resolves `true` on a 2xx accept, `false` on any\n   * non-2xx / thrown error (the http-client has already applied the retry\n   * budget). A stable per-emission `Idempotency-Key` makes this non-idempotent\n   * POST retry-safe and lets the platform ingest dedup a re-delivered event\n   * instead of writing a duplicate audit row (and duplicate chain link).\n   * `Idempotency-Key` is derived from the event so a SPOOLED re-delivery reuses\n   * the same key as its original live attempt — the two collapse to one row.\n   */\n  async function deliver(event: RemoteAuditEvent, serviceName: string): Promise<boolean> {\n    const authHeader = getServiceAuthHeader({ serviceName, orgId: event.orgId, role: 'member' });\n    const headers: Record<string, string> = {\n      'Authorization': authHeader,\n      'Idempotency-Key': event.idempotencyKey ?? randomUUID(),\n    };\n    try {\n      const response = await client.post('/audit/events', event, { headers, ...AUDIT_REQUEST_OPTIONS });\n      const ok = !!response && response.statusCode >= 200 && response.statusCode < 300;\n      if (!ok) {\n        logger.warn('Remote audit ingest non-ok', { action: event.action, statusCode: response?.statusCode });\n      }\n      return ok;\n    } catch (err) {\n      logger.warn('Remote audit ingest threw', { action: event.action, error: err instanceof Error ? err.message : String(err) });\n      return false;\n    }\n  }\n\n  // Serialize spool drains so a periodic tick and an on-success drain can't both\n  // pull the same batch. Stops early the moment a re-delivery fails (platform\n  // still down) so we don't hammer it or churn the buffer.\n  let draining = false;\n  async function drain(): Promise<void> {\n    if (!spool || draining) return;\n    draining = true;\n    try {\n      for (;;) {\n        const batch = await spool.take(drainBatchSize);\n        if (batch.length === 0) return;\n        const delivered: AuditSpoolEntry[] = [];\n        const failed: AuditSpoolEntry[] = [];\n        let platformDown = false;\n        for (const entry of batch) {\n          if (platformDown) { failed.push(entry); continue; }\n          const ok = await deliver(entry.event, entry.serviceName);\n          if (ok) {\n            delivered.push(entry);\n            emitCounter('audit_spool_redelivered_total', { service: entry.serviceName });\n          } else {\n            platformDown = true;\n            failed.push(entry);\n          }\n        }\n        // Acknowledge the delivered prefix so it clears the in-progress list; the\n        // reliable take() moved the whole batch there, so unacked survivors are\n        // reclaimed by recover() after a crash rather than being silently lost.\n        if (delivered.length > 0) await spool.ack(delivered);\n        if (failed.length > 0) {\n          await spool.requeue(failed);\n          return; // still down — try again on the next tick\n        }\n      }\n    } catch (err) {\n      logger.warn('Audit spool drain failed', { error: err instanceof Error ? err.message : String(err) });\n    } finally {\n      draining = false;\n    }\n  }\n\n  let drainTimer: ReturnType<typeof setInterval> | undefined;\n  if (spool) {\n    // Reclaim any batch stranded on the in-progress list by a prior crash, then\n    // attempt to flush it. Both are best-effort (the spool swallows its errors).\n    void spool.recover().then(() => drain());\n    drainTimer = setInterval(() => { void drain(); }, config.drainIntervalMs ?? 30_000);\n    // Don't let the drain timer keep the process alive on shutdown.\n    (drainTimer as unknown as { unref?: () => void }).unref?.();\n  }\n\n  return {\n    record(event, serviceName) {\n      // Stamp when the action actually occurred (survives spool delay) and pin a\n      // stable idempotency key so a live attempt and its spooled retry dedup.\n      const stamped: RemoteAuditEvent = {\n        ...event,\n        occurredAt: event.occurredAt ?? new Date().toISOString(),\n        idempotencyKey: event.idempotencyKey ?? randomUUID(),\n      };\n      void deliver(stamped, serviceName).then((ok) => {\n        if (ok) {\n          emitCounter('audit_emitted_total', { service: serviceName, outcome: stamped.outcome ?? 'success' });\n          if (spool) void drain(); // platform is reachable — flush any backlog\n        } else if (spool) {\n          void spool.enqueue({ event: stamped, serviceName });\n        } else {\n          emitCounter('audit_dropped_total', { service: serviceName });\n        }\n      });\n    },\n    close() {\n      if (drainTimer) { clearInterval(drainTimer); drainTimer = undefined; }\n    },\n  };\n}\n\n/**\n * Register the standard `authz.denied` sink used by every remote-audit service\n * (pipeline, plugin, compliance, quota, message, billing, reporting, …).\n *\n * The shared `requireAuth` gate forwards each DENIED state-changing request to\n * the auditor set via {@link setAuthzDenialAuditor}; this wires that hook to the\n * service's {@link RemoteAuditClient}, forwarding a `failure`-outcome\n * `authz.denied` event so probing / privilege-escalation attempts leave a trail.\n * Emission is fire-and-forget (the client never throws). `getClient` is a getter\n * so the client stays lazily constructed (services memoize it on first use).\n *\n * Platform is intentionally NOT a caller — it is the audit authority and writes\n * `authz.denied` straight to its local store (with `affectedOrgId`), not through\n * a RemoteAuditClient.\n */\nexport function wireAuthzDenialAuditor(serviceName: string, getClient: () => RemoteAuditClient): void {\n  setAuthzDenialAuditor((info: AuthzDenialInfo) => getClient().record({\n    action: 'authz.denied',\n    actorId: info.actorId ?? 'anonymous',\n    actorEmail: info.actorEmail,\n    orgId: info.orgId,\n    outcome: 'failure',\n    details: { method: info.method, path: info.path, required: info.required },\n  }, serviceName));\n}\n\n/**\n * A service-scoped audit client: a durable-spool-backed {@link RemoteAuditClient}\n * with the service name pre-bound for emission. Replaces the per-service\n * boilerplate of `createRemoteAuditClient({ spool: createEnvRedisAuditSpool() ?? undefined })`\n * plus a hand-rolled `emit<Service>Audit` wrapper that repeats the service name.\n */\nexport interface ServiceAuditClient {\n  /** Emit an audit event with the service name bound. Fire-and-forget. */\n  emit(event: RemoteAuditEvent): void;\n  /** The underlying remote client — for `wireAuthzDenialAuditor` + `close()`. */\n  readonly client: RemoteAuditClient;\n}\n\n/**\n * Build a service's audit client: a RemoteAuditClient wired to the durable Redis\n * spool (from ambient env; null → no spool) with `serviceName` bound. Construct\n * ONCE per process — memoize behind a lazy `getAuditClient()` in the service's\n * `services/audit.ts`. Pass `config.spool` to override the env-derived spool\n * (e.g. reuse a service's existing ioredis connection).\n */\nexport function createServiceAuditClient(serviceName: string, config: RemoteAuditClientConfig = {}): ServiceAuditClient {\n  const spool = config.spool ?? createEnvRedisAuditSpool() ?? undefined;\n  const client = createRemoteAuditClient({ ...config, spool });\n  return {\n    emit: (event) => client.record(event, serviceName),\n    client,\n  };\n}\n\n/**\n * Lazily-constructed remote-audit accessor for a service. Every service's\n * `services/audit.ts` used to hand-roll the same module singleton (a `let audit`\n * + `svc()` that builds a {@link ServiceAuditClient} on first use, then a\n * `getAuditClient()` returning `.client` and an `emit(event)` forwarding to\n * `.emit`). This packages that pattern in ONE place so each service's audit\n * wiring is a one-liner and can't drift.\n *\n * Lazy on purpose: the underlying client wires an env-Redis audit spool, so\n * building it at import time would force that connection wherever the module is\n * merely imported (e.g. tests). `getAuditClient` is passed to\n * `wireAuthzDenialAuditor`; `emit` backs the per-service `emitXAudit` helpers.\n * Both stay FIRE-AND-FORGET (record never throws / is not awaited).\n */\nexport function createRemoteAuditAccessor(serviceName: string): {\n  getAuditClient: () => RemoteAuditClient;\n  emit: (event: RemoteAuditEvent) => void;\n} {\n  let audit: ServiceAuditClient | null = null;\n  const svc = (): ServiceAuditClient => {\n    if (!audit) audit = createServiceAuditClient(serviceName);\n    return audit;\n  };\n  return {\n    getAuditClient: () => svc().client,\n    emit: (event) => svc().emit(event),\n  };\n}\n"]}

package/package.json

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