@pipeline-builder/api-core 0.0.1

package/lib/services/retry-strategy.d.ts

@@ -0,0 +1,74 @@
+import * as http from 'http';
+/**
+ * Default retry configuration (env: `HTTP_CLIENT_MAX_RETRIES`, `HTTP_CLIENT_RETRY_DELAY_MS`).
+ */
+export declare const DEFAULT_MAX_RETRIES: number;
+export declare const DEFAULT_RETRY_DELAY_MS: number;
+export declare const DEFAULT_MAX_RATE_LIMIT_RETRIES: number;
+/**
+ * Configuration for retry behavior.
+ */
+export interface RetryConfig {
+    /** Maximum retry attempts for transient failures (default: 2) */
+    maxRetries: number;
+    /** Base delay between retries in ms — doubles each attempt (default: 200) */
+    retryDelayMs: number;
+    /** Maximum retry attempts specifically for 429 rate limiting (default: 4) */
+    maxRateLimitRetries: number;
+}
+/**
+ * Result of a retry decision: whether to retry, and how long to wait.
+ */
+export interface RetryDecision {
+    /** Whether the request should be retried */
+    shouldRetry: boolean;
+    /** Delay in milliseconds before retrying (with jitter applied) */
+    delayMs: number;
+    /** Human-readable reason for the retry decision */
+    reason: string;
+}
+/**
+ * Parse a `Retry-After` header value into milliseconds.
+ * Supports numeric seconds (e.g. "5") and HTTP-date format.
+ * Returns `undefined` for missing or invalid values.
+ */
+export declare function parseRetryAfter(header: string | string[] | undefined): number | undefined;
+/**
+ * Apply +/-25% random jitter to a delay to prevent thundering herd.
+ */
+export declare function addJitter(delay: number): number;
+/**
+ * Calculate exponential backoff delay for a given attempt.
+ *
+ * @param baseDelay - Base delay in milliseconds
+ * @param attempt - Zero-based attempt number
+ * @returns Delay in milliseconds (without jitter)
+ */
+export declare function calculateBackoff(baseDelay: number, attempt: number): number;
+/**
+ * Determine whether a status code represents a transient server error
+ * that is eligible for retry (502, 503, 504).
+ */
+export declare function isTransientStatusCode(statusCode: number): boolean;
+/**
+ * Determine whether a status code indicates rate limiting (429).
+ */
+export declare function isRateLimited(statusCode: number): boolean;
+/**
+ * Determine whether a failed response should be retried, and compute the delay.
+ *
+ * @param statusCode - HTTP status code of the response
+ * @param headers - Response headers (used to read Retry-After for 429)
+ * @param attempt - Zero-based attempt number
+ * @param config - Retry configuration
+ * @returns A RetryDecision indicating whether to retry and the delay
+ */
+export declare function getRetryDecision(statusCode: number, headers: http.IncomingHttpHeaders, attempt: number, config: RetryConfig): RetryDecision;
+/**
+ * Determine whether a connection/timeout error should be retried, and compute the delay.
+ *
+ * @param attempt - Zero-based attempt number
+ * @param config - Retry configuration
+ * @returns A RetryDecision indicating whether to retry and the delay
+ */
+export declare function getErrorRetryDecision(attempt: number, config: RetryConfig): RetryDecision;

package/lib/services/retry-strategy.js

@@ -0,0 +1,118 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import * as http from 'http';
+/**
+ * Default retry configuration (env: `HTTP_CLIENT_MAX_RETRIES`, `HTTP_CLIENT_RETRY_DELAY_MS`).
+ */
+export const DEFAULT_MAX_RETRIES = parseInt(process.env.HTTP_CLIENT_MAX_RETRIES || '2', 10);
+export const DEFAULT_RETRY_DELAY_MS = parseInt(process.env.HTTP_CLIENT_RETRY_DELAY_MS || '200', 10);
+export const DEFAULT_MAX_RATE_LIMIT_RETRIES = parseInt(process.env.HTTP_CLIENT_MAX_RATE_LIMIT_RETRIES || '4', 10);
+/** Max Retry-After value we'll honor (60 seconds). */
+const MAX_RETRY_AFTER_MS = 60_000;
+/** HTTP status codes considered transient server errors eligible for retry. */
+const TRANSIENT_STATUS_CODES = [502, 503, 504];
+/**
+ * Parse a `Retry-After` header value into milliseconds.
+ * Supports numeric seconds (e.g. "5") and HTTP-date format.
+ * Returns `undefined` for missing or invalid values.
+ */
+export function parseRetryAfter(header) {
+    if (!header)
+        return undefined;
+    const value = Array.isArray(header) ? header[0] : header;
+    if (!value)
+        return undefined;
+    // Try numeric seconds first
+    const seconds = Number(value);
+    if (!isNaN(seconds) && seconds >= 0) {
+        return Math.min(seconds * 1000, MAX_RETRY_AFTER_MS);
+    }
+    // Try HTTP-date
+    const date = Date.parse(value);
+    if (!isNaN(date)) {
+        const delayMs = date - Date.now();
+        if (delayMs > 0)
+            return Math.min(delayMs, MAX_RETRY_AFTER_MS);
+    }
+    return undefined;
+}
+/**
+ * Apply +/-25% random jitter to a delay to prevent thundering herd.
+ */
+export function addJitter(delay) {
+    const jitter = delay * 0.25 * (2 * Math.random() - 1); // -25% to +25%
+    return Math.max(0, Math.round(delay + jitter));
+}
+/**
+ * Calculate exponential backoff delay for a given attempt.
+ *
+ * @param baseDelay - Base delay in milliseconds
+ * @param attempt - Zero-based attempt number
+ * @returns Delay in milliseconds (without jitter)
+ */
+export function calculateBackoff(baseDelay, attempt) {
+    return baseDelay * Math.pow(2, attempt);
+}
+/**
+ * Determine whether a status code represents a transient server error
+ * that is eligible for retry (502, 503, 504).
+ */
+export function isTransientStatusCode(statusCode) {
+    return TRANSIENT_STATUS_CODES.includes(statusCode);
+}
+/**
+ * Determine whether a status code indicates rate limiting (429).
+ */
+export function isRateLimited(statusCode) {
+    return statusCode === 429;
+}
+/**
+ * Determine whether a failed response should be retried, and compute the delay.
+ *
+ * @param statusCode - HTTP status code of the response
+ * @param headers - Response headers (used to read Retry-After for 429)
+ * @param attempt - Zero-based attempt number
+ * @param config - Retry configuration
+ * @returns A RetryDecision indicating whether to retry and the delay
+ */
+export function getRetryDecision(statusCode, headers, attempt, config) {
+    // 429 rate limiting — use Retry-After or longer backoff (4x base)
+    if (isRateLimited(statusCode) && attempt < config.maxRateLimitRetries) {
+        const retryAfter = parseRetryAfter(headers['retry-after']);
+        const rawDelay = retryAfter ?? (config.retryDelayMs * 4 * Math.pow(2, attempt));
+        return {
+            shouldRetry: true,
+            delayMs: addJitter(rawDelay),
+            reason: 'Rate limited (429)',
+        };
+    }
+    // 5xx transient server errors — standard exponential backoff
+    if (isTransientStatusCode(statusCode) && attempt < config.maxRetries) {
+        const rawDelay = calculateBackoff(config.retryDelayMs, attempt);
+        return {
+            shouldRetry: true,
+            delayMs: addJitter(rawDelay),
+            reason: `Transient server error (${statusCode})`,
+        };
+    }
+    return { shouldRetry: false, delayMs: 0, reason: 'Not retryable' };
+}
+/**
+ * Determine whether a connection/timeout error should be retried, and compute the delay.
+ *
+ * @param attempt - Zero-based attempt number
+ * @param config - Retry configuration
+ * @returns A RetryDecision indicating whether to retry and the delay
+ */
+export function getErrorRetryDecision(attempt, config) {
+    if (attempt < config.maxRetries) {
+        const rawDelay = calculateBackoff(config.retryDelayMs, attempt);
+        return {
+            shouldRetry: true,
+            delayMs: addJitter(rawDelay),
+            reason: 'Connection or timeout error',
+        };
+    }
+    return { shouldRetry: false, delayMs: 0, reason: 'Max retries exceeded' };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"retry-strategy.js","sourceRoot":"","sources":["../../src/services/retry-strategy.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as http from 'http';\n\n/**\n * Default retry configuration (env: `HTTP_CLIENT_MAX_RETRIES`, `HTTP_CLIENT_RETRY_DELAY_MS`).\n */\nexport const DEFAULT_MAX_RETRIES = parseInt(process.env.HTTP_CLIENT_MAX_RETRIES || '2', 10);\nexport const DEFAULT_RETRY_DELAY_MS = parseInt(process.env.HTTP_CLIENT_RETRY_DELAY_MS || '200', 10);\nexport const DEFAULT_MAX_RATE_LIMIT_RETRIES = parseInt(process.env.HTTP_CLIENT_MAX_RATE_LIMIT_RETRIES || '4', 10);\n\n/** Max Retry-After value we'll honor (60 seconds). */\nconst MAX_RETRY_AFTER_MS = 60_000;\n\n/** HTTP status codes considered transient server errors eligible for retry. */\nconst TRANSIENT_STATUS_CODES = [502, 503, 504];\n\n/**\n * Configuration for retry behavior.\n */\nexport interface RetryConfig {\n  /** Maximum retry attempts for transient failures (default: 2) */\n  maxRetries: number;\n  /** Base delay between retries in ms — doubles each attempt (default: 200) */\n  retryDelayMs: number;\n  /** Maximum retry attempts specifically for 429 rate limiting (default: 4) */\n  maxRateLimitRetries: number;\n}\n\n/**\n * Result of a retry decision: whether to retry, and how long to wait.\n */\nexport interface RetryDecision {\n  /** Whether the request should be retried */\n  shouldRetry: boolean;\n  /** Delay in milliseconds before retrying (with jitter applied) */\n  delayMs: number;\n  /** Human-readable reason for the retry decision */\n  reason: string;\n}\n\n/**\n * Parse a `Retry-After` header value into milliseconds.\n * Supports numeric seconds (e.g. \"5\") and HTTP-date format.\n * Returns `undefined` for missing or invalid values.\n */\nexport function parseRetryAfter(header: string | string[] | undefined): number | undefined {\n  if (!header) return undefined;\n  const value = Array.isArray(header) ? header[0] : header;\n  if (!value) return undefined;\n\n  // Try numeric seconds first\n  const seconds = Number(value);\n  if (!isNaN(seconds) && seconds >= 0) {\n    return Math.min(seconds * 1000, MAX_RETRY_AFTER_MS);\n  }\n\n  // Try HTTP-date\n  const date = Date.parse(value);\n  if (!isNaN(date)) {\n    const delayMs = date - Date.now();\n    if (delayMs > 0) return Math.min(delayMs, MAX_RETRY_AFTER_MS);\n  }\n\n  return undefined;\n}\n\n/**\n * Apply +/-25% random jitter to a delay to prevent thundering herd.\n */\nexport function addJitter(delay: number): number {\n  const jitter = delay * 0.25 * (2 * Math.random() - 1); // -25% to +25%\n  return Math.max(0, Math.round(delay + jitter));\n}\n\n/**\n * Calculate exponential backoff delay for a given attempt.\n *\n * @param baseDelay - Base delay in milliseconds\n * @param attempt - Zero-based attempt number\n * @returns Delay in milliseconds (without jitter)\n */\nexport function calculateBackoff(baseDelay: number, attempt: number): number {\n  return baseDelay * Math.pow(2, attempt);\n}\n\n/**\n * Determine whether a status code represents a transient server error\n * that is eligible for retry (502, 503, 504).\n */\nexport function isTransientStatusCode(statusCode: number): boolean {\n  return TRANSIENT_STATUS_CODES.includes(statusCode);\n}\n\n/**\n * Determine whether a status code indicates rate limiting (429).\n */\nexport function isRateLimited(statusCode: number): boolean {\n  return statusCode === 429;\n}\n\n/**\n * Determine whether a failed response should be retried, and compute the delay.\n *\n * @param statusCode - HTTP status code of the response\n * @param headers - Response headers (used to read Retry-After for 429)\n * @param attempt - Zero-based attempt number\n * @param config - Retry configuration\n * @returns A RetryDecision indicating whether to retry and the delay\n */\nexport function getRetryDecision(\n  statusCode: number,\n  headers: http.IncomingHttpHeaders,\n  attempt: number,\n  config: RetryConfig,\n): RetryDecision {\n  // 429 rate limiting — use Retry-After or longer backoff (4x base)\n  if (isRateLimited(statusCode) && attempt < config.maxRateLimitRetries) {\n    const retryAfter = parseRetryAfter(headers['retry-after']);\n    const rawDelay = retryAfter ?? (config.retryDelayMs * 4 * Math.pow(2, attempt));\n    return {\n      shouldRetry: true,\n      delayMs: addJitter(rawDelay),\n      reason: 'Rate limited (429)',\n    };\n  }\n\n  // 5xx transient server errors — standard exponential backoff\n  if (isTransientStatusCode(statusCode) && attempt < config.maxRetries) {\n    const rawDelay = calculateBackoff(config.retryDelayMs, attempt);\n    return {\n      shouldRetry: true,\n      delayMs: addJitter(rawDelay),\n      reason: `Transient server error (${statusCode})`,\n    };\n  }\n\n  return { shouldRetry: false, delayMs: 0, reason: 'Not retryable' };\n}\n\n/**\n * Determine whether a connection/timeout error should be retried, and compute the delay.\n *\n * @param attempt - Zero-based attempt number\n * @param config - Retry configuration\n * @returns A RetryDecision indicating whether to retry and the delay\n */\nexport function getErrorRetryDecision(\n  attempt: number,\n  config: RetryConfig,\n): RetryDecision {\n  if (attempt < config.maxRetries) {\n    const rawDelay = calculateBackoff(config.retryDelayMs, attempt);\n    return {\n      shouldRetry: true,\n      delayMs: addJitter(rawDelay),\n      reason: 'Connection or timeout error',\n    };\n  }\n\n  return { shouldRetry: false, delayMs: 0, reason: 'Max retries exceeded' };\n}\n"]}

package/lib/services/scheduler.d.ts

@@ -0,0 +1,41 @@
+import { type LockRedis } from './leader-lock.js';
+/** Optional cross-pod single-runner lock for a scheduler's cycle. The redis
+ *  client is resolved per cycle (it may be an async getter, e.g. a BullMQ
+ *  `queue.client` promise). */
+export interface SchedulerLock {
+    redis: () => LockRedis | Promise<LockRedis>;
+    key: string;
+    ttlMs: number;
+}
+export interface SchedulerOptions {
+    /** Log label (also the logger name). */
+    name: string;
+    /** Interval between cycles (ms). */
+    intervalMs: number;
+    /** The work to run each cycle. Errors are caught + logged, never thrown. */
+    run: () => Promise<void>;
+    /** Run a cycle immediately when started. Default true. */
+    runOnStart?: boolean;
+    /** Delay before the first cycle (and before the interval begins), ms.
+     *  Default 0. Lets a service wait for dependencies to come up. */
+    startupDelayMs?: number;
+    /** When set, each cycle runs only on the pod that wins this lock — so with
+     *  multiple replicas only one runs per window. */
+    lock?: SchedulerLock;
+}
+export interface Scheduler {
+    /** Start the timer. Idempotent — repeated calls are no-ops. */
+    start(): void;
+    /** Stop the timer (and cancel a pending startup delay). Safe before start. */
+    stop(): void;
+}
+/**
+ * A periodic background job: a single unref'd `setInterval` with start-once
+ * semantics, error isolation (a throwing cycle is logged, never crashes the
+ * loop), an optional startup delay, and an optional cross-pod leader lock.
+ *
+ * Replaces the hand-rolled timer/`unref`/`catch`/start-stop boilerplate that
+ * each scheduler (scan, digest, registry GC, billing lifecycle) repeated, and
+ * makes the leader lock available to all of them uniformly.
+ */
+export declare function createScheduler(opts: SchedulerOptions): Scheduler;

package/lib/services/scheduler.js

@@ -0,0 +1,86 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { withLeaderLock } from './leader-lock.js';
+import { createLogger } from '../utils/logger.js';
+const errorMessage = (e) => (e instanceof Error ? e.message : String(e));
+/**
+ * A periodic background job: a single unref'd `setInterval` with start-once
+ * semantics, error isolation (a throwing cycle is logged, never crashes the
+ * loop), an optional startup delay, and an optional cross-pod leader lock.
+ *
+ * Replaces the hand-rolled timer/`unref`/`catch`/start-stop boilerplate that
+ * each scheduler (scan, digest, registry GC, billing lifecycle) repeated, and
+ * makes the leader lock available to all of them uniformly.
+ */
+export function createScheduler(opts) {
+    const log = createLogger(opts.name);
+    let interval = null;
+    let startup = null;
+    let stopped = false;
+    let running = false;
+    const cycle = async () => {
+        // Same-pod re-entrancy guard: setInterval doesn't await the async cycle, so
+        // a cycle slower than intervalMs would otherwise overlap ITSELF on this pod
+        // (double-processing, duplicate side effects). The optional leader lock only
+        // guards CROSS-pod overlap; this guards same-pod. A skipped tick just runs on
+        // the next interval.
+        if (running) {
+            log.debug('Cycle skipped — previous cycle still running (same-pod re-entrancy)');
+            return;
+        }
+        running = true;
+        try {
+            if (opts.lock) {
+                const redis = await opts.lock.redis();
+                const ran = await withLeaderLock(redis, opts.lock.key, opts.lock.ttlMs, opts.run);
+                if (!ran)
+                    log.debug('Cycle skipped — another pod holds the lock');
+            }
+            else {
+                await opts.run();
+            }
+        }
+        catch (err) {
+            log.error('Scheduler cycle failed', { error: errorMessage(err) });
+        }
+        finally {
+            running = false;
+        }
+    };
+    const begin = () => {
+        if (stopped)
+            return; // stop() called during the startup delay
+        if (opts.runOnStart !== false)
+            void cycle();
+        interval = setInterval(() => void cycle(), opts.intervalMs);
+        interval.unref();
+    };
+    return {
+        start() {
+            if (interval || startup)
+                return;
+            stopped = false;
+            if (opts.startupDelayMs && opts.startupDelayMs > 0) {
+                startup = setTimeout(() => { startup = null; begin(); }, opts.startupDelayMs);
+                startup.unref();
+            }
+            else {
+                begin();
+            }
+            log.info('Scheduler started', { intervalMs: opts.intervalMs, locked: !!opts.lock });
+        },
+        stop() {
+            stopped = true;
+            if (startup) {
+                clearTimeout(startup);
+                startup = null;
+            }
+            if (interval) {
+                clearInterval(interval);
+                interval = null;
+            }
+            log.info('Scheduler stopped');
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scheduler.js","sourceRoot":"","sources":["../../src/services/scheduler.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { withLeaderLock, type LockRedis } from './leader-lock.js';\nimport { createLogger } from '../utils/logger.js';\n\nconst errorMessage = (e: unknown) => (e instanceof Error ? e.message : String(e));\n\n/** Optional cross-pod single-runner lock for a scheduler's cycle. The redis\n *  client is resolved per cycle (it may be an async getter, e.g. a BullMQ\n *  `queue.client` promise). */\nexport interface SchedulerLock {\n  redis: () => LockRedis | Promise<LockRedis>;\n  key: string;\n  ttlMs: number;\n}\n\nexport interface SchedulerOptions {\n  /** Log label (also the logger name). */\n  name: string;\n  /** Interval between cycles (ms). */\n  intervalMs: number;\n  /** The work to run each cycle. Errors are caught + logged, never thrown. */\n  run: () => Promise<void>;\n  /** Run a cycle immediately when started. Default true. */\n  runOnStart?: boolean;\n  /** Delay before the first cycle (and before the interval begins), ms.\n   *  Default 0. Lets a service wait for dependencies to come up. */\n  startupDelayMs?: number;\n  /** When set, each cycle runs only on the pod that wins this lock — so with\n   *  multiple replicas only one runs per window. */\n  lock?: SchedulerLock;\n}\n\nexport interface Scheduler {\n  /** Start the timer. Idempotent — repeated calls are no-ops. */\n  start(): void;\n  /** Stop the timer (and cancel a pending startup delay). Safe before start. */\n  stop(): void;\n}\n\n/**\n * A periodic background job: a single unref'd `setInterval` with start-once\n * semantics, error isolation (a throwing cycle is logged, never crashes the\n * loop), an optional startup delay, and an optional cross-pod leader lock.\n *\n * Replaces the hand-rolled timer/`unref`/`catch`/start-stop boilerplate that\n * each scheduler (scan, digest, registry GC, billing lifecycle) repeated, and\n * makes the leader lock available to all of them uniformly.\n */\nexport function createScheduler(opts: SchedulerOptions): Scheduler {\n  const log = createLogger(opts.name);\n  let interval: ReturnType<typeof setInterval> | null = null;\n  let startup: ReturnType<typeof setTimeout> | null = null;\n  let stopped = false;\n  let running = false;\n\n  const cycle = async (): Promise<void> => {\n    // Same-pod re-entrancy guard: setInterval doesn't await the async cycle, so\n    // a cycle slower than intervalMs would otherwise overlap ITSELF on this pod\n    // (double-processing, duplicate side effects). The optional leader lock only\n    // guards CROSS-pod overlap; this guards same-pod. A skipped tick just runs on\n    // the next interval.\n    if (running) {\n      log.debug('Cycle skipped — previous cycle still running (same-pod re-entrancy)');\n      return;\n    }\n    running = true;\n    try {\n      if (opts.lock) {\n        const redis = await opts.lock.redis();\n        const ran = await withLeaderLock(redis, opts.lock.key, opts.lock.ttlMs, opts.run);\n        if (!ran) log.debug('Cycle skipped — another pod holds the lock');\n      } else {\n        await opts.run();\n      }\n    } catch (err) {\n      log.error('Scheduler cycle failed', { error: errorMessage(err) });\n    } finally {\n      running = false;\n    }\n  };\n\n  const begin = (): void => {\n    if (stopped) return; // stop() called during the startup delay\n    if (opts.runOnStart !== false) void cycle();\n    interval = setInterval(() => void cycle(), opts.intervalMs);\n    interval.unref();\n  };\n\n  return {\n    start(): void {\n      if (interval || startup) return;\n      stopped = false;\n      if (opts.startupDelayMs && opts.startupDelayMs > 0) {\n        startup = setTimeout(() => { startup = null; begin(); }, opts.startupDelayMs);\n        startup.unref();\n      } else {\n        begin();\n      }\n      log.info('Scheduler started', { intervalMs: opts.intervalMs, locked: !!opts.lock });\n    },\n    stop(): void {\n      stopped = true;\n      if (startup) { clearTimeout(startup); startup = null; }\n      if (interval) { clearInterval(interval); interval = null; }\n      log.info('Scheduler stopped');\n    },\n  };\n}\n"]}

package/lib/services/service-boot.d.ts

@@ -0,0 +1,20 @@
+import type { RemoteAuditClient } from './remote-audit-client.js';
+/**
+ * Wire the two boot-security concerns every stateless service sets up
+ * identically at startup:
+ *   1. forward denied (non-GET) authorizations to the shared `authz.denied`
+ *      audit sink (`wireAuthzDenialAuditor`);
+ *   2. register the env-Redis token-revocation reader (fail-open) so
+ *      `requireAuth` can reject a token behind the platform-published
+ *      `tokenVersion` (`setTokenRevocationStore(createEnvRedisTokenRevocationStore())`).
+ *
+ * Collapses the two copy-pasted lines in each service's `index.ts` into one call.
+ *
+ * NOTE: the PLUGIN service opts out — it shares its health-check Redis
+ * connection via `createRedisTokenRevocationStore(getHealthRedisConnection())`
+ * instead of the env-Redis store — so it wires these two concerns by hand.
+ *
+ * @param serviceName short service name minted into the `authz.denied` records
+ * @param getAuditClient lazy accessor for the service's RemoteAuditClient
+ */
+export declare function wireServiceSecurity(serviceName: string, getAuditClient: () => RemoteAuditClient): void;

package/lib/services/service-boot.js

@@ -0,0 +1,28 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { wireAuthzDenialAuditor } from './remote-audit-client.js';
+import { createEnvRedisTokenRevocationStore } from './token-revocation.js';
+import { setTokenRevocationStore } from '../middleware/auth.js';
+/**
+ * Wire the two boot-security concerns every stateless service sets up
+ * identically at startup:
+ *   1. forward denied (non-GET) authorizations to the shared `authz.denied`
+ *      audit sink (`wireAuthzDenialAuditor`);
+ *   2. register the env-Redis token-revocation reader (fail-open) so
+ *      `requireAuth` can reject a token behind the platform-published
+ *      `tokenVersion` (`setTokenRevocationStore(createEnvRedisTokenRevocationStore())`).
+ *
+ * Collapses the two copy-pasted lines in each service's `index.ts` into one call.
+ *
+ * NOTE: the PLUGIN service opts out — it shares its health-check Redis
+ * connection via `createRedisTokenRevocationStore(getHealthRedisConnection())`
+ * instead of the env-Redis store — so it wires these two concerns by hand.
+ *
+ * @param serviceName short service name minted into the `authz.denied` records
+ * @param getAuditClient lazy accessor for the service's RemoteAuditClient
+ */
+export function wireServiceSecurity(serviceName, getAuditClient) {
+    wireAuthzDenialAuditor(serviceName, getAuditClient);
+    setTokenRevocationStore(createEnvRedisTokenRevocationStore());
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/services/sse-ticket-store.d.ts

@@ -0,0 +1,51 @@
+/** Result of {@link SseTicketStore.issue}. */
+export type SseTicketIssueResult = {
+    ok: true;
+    ticket: string;
+} | {
+    ok: false;
+    reason: 'total' | 'org';
+};
+/**
+ * Store for short-lived, single-use SSE auth tickets. A client exchanges its JWT
+ * for a ticket (so the token never lands in an EventSource query string / access
+ * log), then redeems it on the SSE `GET`.
+ *
+ * The store is the multi-replica correctness boundary: a ticket minted on pod A
+ * MUST be redeemable on pod B. The Redis backend makes that true; the in-memory
+ * backend is a single-process fallback for dev / single-replica installs.
+ */
+export interface SseTicketStore {
+    /** Mint a ticket for `orgId`, or reject when a rate window is saturated. */
+    issue(orgId: string): Promise<SseTicketIssueResult>;
+    /** Atomically redeem a ticket exactly once; returns its org or null if invalid/expired/spent. */
+    consume(ticketId: string): Promise<{
+        orgId: string;
+    } | null>;
+    /** Release timers/resources. In-memory clears its sweep interval; Redis is a no-op. */
+    stop(): void;
+}
+/** Caps + TTL for the ticket store. */
+export interface SseTicketStoreConfig {
+    /** Ticket lifetime — long enough for the client to open the EventSource. */
+    ttlMs: number;
+    /** Hard cap on tickets minted per TTL window across all orgs (abuse bound). */
+    maxTotal: number;
+    /** Per-org cap on tickets minted per TTL window (single-tenant abuse bound). */
+    maxPerOrg: number;
+    /**
+     * Optional Redis key namespace so independent channels (e.g. message
+     * notifications vs. reporting execution-status) don't share one ticket
+     * keyspace — a ticket minted for one channel must not be redeemable on
+     * another. Omit for the default (shared) namespace.
+     */
+    keyPrefix?: string;
+}
+/**
+ * Build an {@link SseTicketStore} from the standard Redis env (`REDIS_URL` or
+ * `REDIS_HOST`/`REDIS_PORT`). Uses the Redis backend when configured
+ * (multi-replica safe), otherwise falls back to the in-memory single-process
+ * backend. A service opts in with one boot line:
+ *   `const tickets = createEnvSseTicketStore({ ttlMs, maxTotal, maxPerOrg });`
+ */
+export declare function createEnvSseTicketStore(config: SseTicketStoreConfig): SseTicketStore;

package/lib/services/sse-ticket-store.js

@@ -0,0 +1,130 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import crypto from 'crypto';
+import { createEnvRedisClient } from './env-redis.js';
+import { createLogger } from '../utils/logger.js';
+const logger = createLogger('sse-ticket-store');
+/** Redis key namespaces. Ticket → orgId; windowed issue counters bound abuse. */
+const TICKET_KEY_PREFIX = 'sse:tk:';
+const ORG_COUNT_PREFIX = 'sse:tkc:';
+const TOTAL_COUNT_KEY = 'sse:tkc:__all__';
+function newTicketId() {
+    return crypto.randomBytes(24).toString('base64url');
+}
+/**
+ * In-memory backend — the original single-process behaviour. Counts LIVE
+ * (unexpired) tickets per org and evicts expired entries on a timer. Correct
+ * only within one process, so it is the fallback used when Redis isn't configured.
+ */
+function createInMemorySseTicketStore(config) {
+    const store = new Map();
+    const cleanup = setInterval(() => {
+        const now = Date.now();
+        for (const [id, t] of store)
+            if (now > t.expiresAt)
+                store.delete(id);
+    }, config.ttlMs);
+    cleanup.unref();
+    function countLiveForOrg(orgId, now) {
+        let count = 0;
+        for (const t of store.values())
+            if (t.orgId === orgId && t.expiresAt > now)
+                count++;
+        return count;
+    }
+    return {
+        async issue(orgId) {
+            const now = Date.now();
+            if (store.size >= config.maxTotal)
+                return { ok: false, reason: 'total' };
+            if (countLiveForOrg(orgId, now) >= config.maxPerOrg)
+                return { ok: false, reason: 'org' };
+            const ticket = newTicketId();
+            store.set(ticket, { orgId, expiresAt: now + config.ttlMs });
+            return { ok: true, ticket };
+        },
+        async consume(ticketId) {
+            const t = store.get(ticketId);
+            store.delete(ticketId); // single-use — consume immediately
+            if (!t || Date.now() > t.expiresAt)
+                return null;
+            return { orgId: t.orgId };
+        },
+        stop() { clearInterval(cleanup); },
+    };
+}
+/**
+ * Redis backend — multi-replica safe. Tickets live under a TTL'd key so any pod
+ * can redeem one; {@link SseTicketStore.consume} uses GETDEL so redemption is
+ * atomic (two pods can't both spend the same ticket). The per-org / global caps
+ * become windowed rate limits (max mints per TTL window) via INCR + first-hit
+ * EXPIRE — equivalent abuse bounding to the in-memory live-count, and it also
+ * caps churn.
+ *
+ * Fail-CLOSED by design (unlike the fail-open token-revocation reader): if Redis
+ * errors, `issue` returns a cap rejection and `consume` returns null, so a Redis
+ * outage degrades to "no live notifications" rather than handing out or
+ * accepting unvalidated tickets. SSE notifications are non-critical, so failing
+ * closed here costs only real-time delivery, never correctness.
+ */
+function createRedisSseTicketStore(redis, config) {
+    const ttlSec = Math.max(1, Math.ceil(config.ttlMs / 1000));
+    // Per-channel namespace so two services' ticket stores don't share keys.
+    const ns = config.keyPrefix ? `${config.keyPrefix}:` : '';
+    const ticketKey = (t) => `${ns}${TICKET_KEY_PREFIX}${t}`;
+    const orgCountKey = (o) => `${ns}${ORG_COUNT_PREFIX}${o}`;
+    const totalCountKey = `${ns}${TOTAL_COUNT_KEY}`;
+    // Windowed counter: INCR, and on the first hit of a window set the TTL so it
+    // auto-resets. Returns true while still within `limit` for this window.
+    async function withinWindow(key, limit) {
+        const n = await redis.incr(key);
+        if (n === 1)
+            await redis.expire(key, ttlSec);
+        return n <= limit;
+    }
+    return {
+        async issue(orgId) {
+            try {
+                if (!(await withinWindow(totalCountKey, config.maxTotal)))
+                    return { ok: false, reason: 'total' };
+                if (!(await withinWindow(orgCountKey(orgId), config.maxPerOrg)))
+                    return { ok: false, reason: 'org' };
+                const ticket = newTicketId();
+                await redis.set(ticketKey(ticket), orgId, 'EX', ttlSec);
+                return { ok: true, ticket };
+            }
+            catch (err) {
+                logger.warn('SSE ticket issue failed (fail-closed)', { error: err instanceof Error ? err.message : String(err) });
+                return { ok: false, reason: 'total' };
+            }
+        },
+        async consume(ticketId) {
+            try {
+                const orgId = await redis.getdel(ticketKey(ticketId));
+                return orgId ? { orgId } : null;
+            }
+            catch (err) {
+                logger.warn('SSE ticket consume failed (fail-closed)', { error: err instanceof Error ? err.message : String(err) });
+                return null;
+            }
+        },
+        stop() { },
+    };
+}
+/**
+ * Build an {@link SseTicketStore} from the standard Redis env (`REDIS_URL` or
+ * `REDIS_HOST`/`REDIS_PORT`). Uses the Redis backend when configured
+ * (multi-replica safe), otherwise falls back to the in-memory single-process
+ * backend. A service opts in with one boot line:
+ *   `const tickets = createEnvSseTicketStore({ ttlMs, maxTotal, maxPerOrg });`
+ */
+export function createEnvSseTicketStore(config) {
+    const redis = createEnvRedisClient('sse-ticket');
+    if (redis) {
+        logger.info('SSE ticket store: Redis backend (multi-replica)');
+        return createRedisSseTicketStore(redis, config);
+    }
+    logger.info('SSE ticket store: in-memory backend (single-process fallback)');
+    return createInMemorySseTicketStore(config);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sse-ticket-store.js","sourceRoot":"","sources":["../../src/services/sse-ticket-store.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport crypto from 'crypto';\n\nimport { createEnvRedisClient } from './env-redis.js';\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('sse-ticket-store');\n\n/** Redis key namespaces. Ticket → orgId; windowed issue counters bound abuse. */\nconst TICKET_KEY_PREFIX = 'sse:tk:';\nconst ORG_COUNT_PREFIX = 'sse:tkc:';\nconst TOTAL_COUNT_KEY = 'sse:tkc:__all__';\n\n/** Result of {@link SseTicketStore.issue}. */\nexport type SseTicketIssueResult =\n  | { ok: true; ticket: string }\n  | { ok: false; reason: 'total' | 'org' };\n\n/**\n * Store for short-lived, single-use SSE auth tickets. A client exchanges its JWT\n * for a ticket (so the token never lands in an EventSource query string / access\n * log), then redeems it on the SSE `GET`.\n *\n * The store is the multi-replica correctness boundary: a ticket minted on pod A\n * MUST be redeemable on pod B. The Redis backend makes that true; the in-memory\n * backend is a single-process fallback for dev / single-replica installs.\n */\nexport interface SseTicketStore {\n  /** Mint a ticket for `orgId`, or reject when a rate window is saturated. */\n  issue(orgId: string): Promise<SseTicketIssueResult>;\n  /** Atomically redeem a ticket exactly once; returns its org or null if invalid/expired/spent. */\n  consume(ticketId: string): Promise<{ orgId: string } | null>;\n  /** Release timers/resources. In-memory clears its sweep interval; Redis is a no-op. */\n  stop(): void;\n}\n\n/** Caps + TTL for the ticket store. */\nexport interface SseTicketStoreConfig {\n  /** Ticket lifetime — long enough for the client to open the EventSource. */\n  ttlMs: number;\n  /** Hard cap on tickets minted per TTL window across all orgs (abuse bound). */\n  maxTotal: number;\n  /** Per-org cap on tickets minted per TTL window (single-tenant abuse bound). */\n  maxPerOrg: number;\n  /**\n   * Optional Redis key namespace so independent channels (e.g. message\n   * notifications vs. reporting execution-status) don't share one ticket\n   * keyspace — a ticket minted for one channel must not be redeemable on\n   * another. Omit for the default (shared) namespace.\n   */\n  keyPrefix?: string;\n}\n\n/** Minimal ioredis surface this store needs (GETDEL requires Redis ≥ 6.2). */\ninterface SseRedis {\n  incr(key: string): Promise<number>;\n  expire(key: string, seconds: number): Promise<unknown>;\n  set(key: string, value: string, ...args: unknown[]): Promise<unknown>;\n  getdel(key: string): Promise<string | null>;\n}\n\nfunction newTicketId(): string {\n  return crypto.randomBytes(24).toString('base64url');\n}\n\n/**\n * In-memory backend — the original single-process behaviour. Counts LIVE\n * (unexpired) tickets per org and evicts expired entries on a timer. Correct\n * only within one process, so it is the fallback used when Redis isn't configured.\n */\nfunction createInMemorySseTicketStore(config: SseTicketStoreConfig): SseTicketStore {\n  interface Entry { orgId: string; expiresAt: number }\n  const store = new Map<string, Entry>();\n\n  const cleanup = setInterval(() => {\n    const now = Date.now();\n    for (const [id, t] of store) if (now > t.expiresAt) store.delete(id);\n  }, config.ttlMs);\n  cleanup.unref();\n\n  function countLiveForOrg(orgId: string, now: number): number {\n    let count = 0;\n    for (const t of store.values()) if (t.orgId === orgId && t.expiresAt > now) count++;\n    return count;\n  }\n\n  return {\n    async issue(orgId: string): Promise<SseTicketIssueResult> {\n      const now = Date.now();\n      if (store.size >= config.maxTotal) return { ok: false, reason: 'total' };\n      if (countLiveForOrg(orgId, now) >= config.maxPerOrg) return { ok: false, reason: 'org' };\n      const ticket = newTicketId();\n      store.set(ticket, { orgId, expiresAt: now + config.ttlMs });\n      return { ok: true, ticket };\n    },\n    async consume(ticketId: string): Promise<{ orgId: string } | null> {\n      const t = store.get(ticketId);\n      store.delete(ticketId); // single-use — consume immediately\n      if (!t || Date.now() > t.expiresAt) return null;\n      return { orgId: t.orgId };\n    },\n    stop(): void { clearInterval(cleanup); },\n  };\n}\n\n/**\n * Redis backend — multi-replica safe. Tickets live under a TTL'd key so any pod\n * can redeem one; {@link SseTicketStore.consume} uses GETDEL so redemption is\n * atomic (two pods can't both spend the same ticket). The per-org / global caps\n * become windowed rate limits (max mints per TTL window) via INCR + first-hit\n * EXPIRE — equivalent abuse bounding to the in-memory live-count, and it also\n * caps churn.\n *\n * Fail-CLOSED by design (unlike the fail-open token-revocation reader): if Redis\n * errors, `issue` returns a cap rejection and `consume` returns null, so a Redis\n * outage degrades to \"no live notifications\" rather than handing out or\n * accepting unvalidated tickets. SSE notifications are non-critical, so failing\n * closed here costs only real-time delivery, never correctness.\n */\nfunction createRedisSseTicketStore(redis: SseRedis, config: SseTicketStoreConfig): SseTicketStore {\n  const ttlSec = Math.max(1, Math.ceil(config.ttlMs / 1000));\n  // Per-channel namespace so two services' ticket stores don't share keys.\n  const ns = config.keyPrefix ? `${config.keyPrefix}:` : '';\n  const ticketKey = (t: string) => `${ns}${TICKET_KEY_PREFIX}${t}`;\n  const orgCountKey = (o: string) => `${ns}${ORG_COUNT_PREFIX}${o}`;\n  const totalCountKey = `${ns}${TOTAL_COUNT_KEY}`;\n\n  // Windowed counter: INCR, and on the first hit of a window set the TTL so it\n  // auto-resets. Returns true while still within `limit` for this window.\n  async function withinWindow(key: string, limit: number): Promise<boolean> {\n    const n = await redis.incr(key);\n    if (n === 1) await redis.expire(key, ttlSec);\n    return n <= limit;\n  }\n\n  return {\n    async issue(orgId: string): Promise<SseTicketIssueResult> {\n      try {\n        if (!(await withinWindow(totalCountKey, config.maxTotal))) return { ok: false, reason: 'total' };\n        if (!(await withinWindow(orgCountKey(orgId), config.maxPerOrg))) return { ok: false, reason: 'org' };\n        const ticket = newTicketId();\n        await redis.set(ticketKey(ticket), orgId, 'EX', ttlSec);\n        return { ok: true, ticket };\n      } catch (err) {\n        logger.warn('SSE ticket issue failed (fail-closed)', { error: err instanceof Error ? err.message : String(err) });\n        return { ok: false, reason: 'total' };\n      }\n    },\n    async consume(ticketId: string): Promise<{ orgId: string } | null> {\n      try {\n        const orgId = await redis.getdel(ticketKey(ticketId));\n        return orgId ? { orgId } : null;\n      } catch (err) {\n        logger.warn('SSE ticket consume failed (fail-closed)', { error: err instanceof Error ? err.message : String(err) });\n        return null;\n      }\n    },\n    stop(): void { /* Redis keys expire on their own TTL — nothing to release. */ },\n  };\n}\n\n/**\n * Build an {@link SseTicketStore} from the standard Redis env (`REDIS_URL` or\n * `REDIS_HOST`/`REDIS_PORT`). Uses the Redis backend when configured\n * (multi-replica safe), otherwise falls back to the in-memory single-process\n * backend. A service opts in with one boot line:\n *   `const tickets = createEnvSseTicketStore({ ttlMs, maxTotal, maxPerOrg });`\n */\nexport function createEnvSseTicketStore(config: SseTicketStoreConfig): SseTicketStore {\n  const redis = createEnvRedisClient<SseRedis>('sse-ticket');\n  if (redis) {\n    logger.info('SSE ticket store: Redis backend (multi-replica)');\n    return createRedisSseTicketStore(redis, config);\n  }\n  logger.info('SSE ticket store: in-memory backend (single-process fallback)');\n  return createInMemorySseTicketStore(config);\n}\n"]}