@pipeline-builder/api-core 0.0.1

package/lib/services/circuit-breaker.d.ts

@@ -0,0 +1,45 @@
+export type CircuitState = 'closed' | 'open' | 'half-open';
+export interface CircuitBreakerConfig {
+    /** Consecutive failures that trip the breaker from closed → open. */
+    failureThreshold: number;
+    /** How long to stay open before allowing a half-open probe (ms). */
+    cooldownMs: number;
+    /** Master switch — when false, allowRequest() is always true and no state moves. */
+    enabled: boolean;
+}
+export declare const DEFAULT_BREAKER_CONFIG: CircuitBreakerConfig;
+/**
+ * A single target's breaker. Not concurrency-locked (JS is single-threaded per
+ * event loop); `probeInFlight` gates half-open to one in-flight probe so a burst
+ * during cooldown doesn't stampede the recovering downstream.
+ */
+export declare class CircuitBreaker {
+    private readonly key;
+    private readonly config;
+    private state;
+    private consecutiveFailures;
+    private openedAt;
+    private probeInFlight;
+    constructor(key: string, config?: CircuitBreakerConfig);
+    getState(): CircuitState;
+    /**
+     * Whether a request may proceed. Transitions open→half-open once the cooldown
+     * elapses and lets exactly ONE probe through. Returns false when open (or a
+     * probe is already in flight) — the caller must fast-fail without any network.
+     */
+    allowRequest(): boolean;
+    /** A logical request succeeded (2xx/3xx/4xx that isn't a downstream fault). */
+    recordSuccess(): void;
+    /** A logical request failed (connection error, timeout, or 5xx response). */
+    recordFailure(): void;
+    private open;
+}
+/** Get (or lazily create) the shared breaker for a `host:port` target. */
+export declare function getCircuitBreaker(key: string): CircuitBreaker;
+/** Test helper: clear all breaker state so suites don't leak across each other. */
+export declare function resetCircuitBreakers(): void;
+/** Thrown by the client when a request is fast-failed because the breaker is open. */
+export declare class CircuitOpenError extends Error {
+    readonly code = "CIRCUIT_OPEN";
+    constructor(target: string);
+}

package/lib/services/circuit-breaker.js

@@ -0,0 +1,138 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Per-target circuit breaker for service-to-service calls.
+ *
+ * The shared {@link InternalHttpClient} already has timeouts, a bounded socket
+ * pool, and bounded retry-with-jitter — but no load-shedding. Under a sustained
+ * downstream brownout every caller keeps paying `timeout × (maxRetries+1)` per
+ * request, saturating the socket pool and turning one slow dependency into a
+ * fleet-wide latency cascade (the classic retry storm). Worse for fail-CLOSED
+ * dependencies (compliance): a brownout there blocks plugin/pipeline creation
+ * with full retry latency on every request.
+ *
+ * This breaker short-circuits that: after `failureThreshold` consecutive
+ * failures to a target it OPENS and fast-fails (no network, no retries) for
+ * `cooldownMs`, then allows a single half-open probe. A fail-closed caller still
+ * fails closed — just immediately, instead of after the full retry budget; a
+ * fail-open caller (createSafeClient) gets its `null` immediately.
+ *
+ * State is keyed by `host:port` in a process-level registry so it is shared even
+ * when callers mint a fresh client per request — one bad target trips once, not
+ * once-per-client. Disable entirely with `S2S_BREAKER_ENABLED=false`.
+ */
+import { envInt, envBool } from '../utils/env.js';
+import { createLogger } from '../utils/logger.js';
+import { emitCounter } from '../utils/metric-emitter.js';
+const logger = createLogger('circuit-breaker');
+export const DEFAULT_BREAKER_CONFIG = {
+    failureThreshold: envInt('S2S_BREAKER_THRESHOLD', 5, { min: 1 }),
+    cooldownMs: envInt('S2S_BREAKER_COOLDOWN_MS', 10000, { min: 1 }),
+    enabled: envBool('S2S_BREAKER_ENABLED', true),
+};
+/**
+ * A single target's breaker. Not concurrency-locked (JS is single-threaded per
+ * event loop); `probeInFlight` gates half-open to one in-flight probe so a burst
+ * during cooldown doesn't stampede the recovering downstream.
+ */
+export class CircuitBreaker {
+    key;
+    config;
+    state = 'closed';
+    consecutiveFailures = 0;
+    openedAt = 0;
+    probeInFlight = false;
+    constructor(key, config = DEFAULT_BREAKER_CONFIG) {
+        this.key = key;
+        this.config = config;
+    }
+    getState() {
+        return this.state;
+    }
+    /**
+     * Whether a request may proceed. Transitions open→half-open once the cooldown
+     * elapses and lets exactly ONE probe through. Returns false when open (or a
+     * probe is already in flight) — the caller must fast-fail without any network.
+     */
+    allowRequest() {
+        if (!this.config.enabled)
+            return true;
+        if (this.state === 'closed')
+            return true;
+        if (this.state === 'open') {
+            if (Date.now() - this.openedAt >= this.config.cooldownMs) {
+                this.state = 'half-open';
+                this.probeInFlight = true;
+                return true;
+            }
+            return false;
+        }
+        // half-open: allow only a single probe at a time.
+        if (this.probeInFlight)
+            return false;
+        this.probeInFlight = true;
+        return true;
+    }
+    /** A logical request succeeded (2xx/3xx/4xx that isn't a downstream fault). */
+    recordSuccess() {
+        if (!this.config.enabled)
+            return;
+        this.consecutiveFailures = 0;
+        this.probeInFlight = false;
+        if (this.state !== 'closed') {
+            logger.info('circuit closed (downstream recovered)', { target: this.key });
+            this.state = 'closed';
+        }
+    }
+    /** A logical request failed (connection error, timeout, or 5xx response). */
+    recordFailure() {
+        if (!this.config.enabled)
+            return;
+        this.probeInFlight = false;
+        this.consecutiveFailures++;
+        // A failed half-open probe means the downstream is still bad — re-open.
+        if (this.state === 'half-open') {
+            this.open();
+            return;
+        }
+        if (this.state === 'closed' && this.consecutiveFailures >= this.config.failureThreshold) {
+            this.open();
+        }
+    }
+    open() {
+        const wasOpen = this.state === 'open';
+        this.state = 'open';
+        this.openedAt = Date.now();
+        if (!wasOpen) {
+            logger.warn('circuit opened — shedding load to target', {
+                target: this.key,
+                consecutiveFailures: this.consecutiveFailures,
+                cooldownMs: this.config.cooldownMs,
+            });
+            emitCounter('s2s_circuit_opened_total', { target: this.key });
+        }
+    }
+}
+const registry = new Map();
+/** Get (or lazily create) the shared breaker for a `host:port` target. */
+export function getCircuitBreaker(key) {
+    let breaker = registry.get(key);
+    if (!breaker) {
+        breaker = new CircuitBreaker(key);
+        registry.set(key, breaker);
+    }
+    return breaker;
+}
+/** Test helper: clear all breaker state so suites don't leak across each other. */
+export function resetCircuitBreakers() {
+    registry.clear();
+}
+/** Thrown by the client when a request is fast-failed because the breaker is open. */
+export class CircuitOpenError extends Error {
+    code = 'CIRCUIT_OPEN';
+    constructor(target) {
+        super(`Circuit open for ${target} — fast-failing to shed load`);
+        this.name = 'CircuitOpenError';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"circuit-breaker.js","sourceRoot":"","sources":["../../src/services/circuit-breaker.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Per-target circuit breaker for service-to-service calls.\n *\n * The shared {@link InternalHttpClient} already has timeouts, a bounded socket\n * pool, and bounded retry-with-jitter — but no load-shedding. Under a sustained\n * downstream brownout every caller keeps paying `timeout × (maxRetries+1)` per\n * request, saturating the socket pool and turning one slow dependency into a\n * fleet-wide latency cascade (the classic retry storm). Worse for fail-CLOSED\n * dependencies (compliance): a brownout there blocks plugin/pipeline creation\n * with full retry latency on every request.\n *\n * This breaker short-circuits that: after `failureThreshold` consecutive\n * failures to a target it OPENS and fast-fails (no network, no retries) for\n * `cooldownMs`, then allows a single half-open probe. A fail-closed caller still\n * fails closed — just immediately, instead of after the full retry budget; a\n * fail-open caller (createSafeClient) gets its `null` immediately.\n *\n * State is keyed by `host:port` in a process-level registry so it is shared even\n * when callers mint a fresh client per request — one bad target trips once, not\n * once-per-client. Disable entirely with `S2S_BREAKER_ENABLED=false`.\n */\n\nimport { envInt, envBool } from '../utils/env.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('circuit-breaker');\n\nexport type CircuitState = 'closed' | 'open' | 'half-open';\n\nexport interface CircuitBreakerConfig {\n  /** Consecutive failures that trip the breaker from closed → open. */\n  failureThreshold: number;\n  /** How long to stay open before allowing a half-open probe (ms). */\n  cooldownMs: number;\n  /** Master switch — when false, allowRequest() is always true and no state moves. */\n  enabled: boolean;\n}\n\nexport const DEFAULT_BREAKER_CONFIG: CircuitBreakerConfig = {\n  failureThreshold: envInt('S2S_BREAKER_THRESHOLD', 5, { min: 1 }),\n  cooldownMs: envInt('S2S_BREAKER_COOLDOWN_MS', 10000, { min: 1 }),\n  enabled: envBool('S2S_BREAKER_ENABLED', true),\n};\n\n/**\n * A single target's breaker. Not concurrency-locked (JS is single-threaded per\n * event loop); `probeInFlight` gates half-open to one in-flight probe so a burst\n * during cooldown doesn't stampede the recovering downstream.\n */\nexport class CircuitBreaker {\n  private state: CircuitState = 'closed';\n  private consecutiveFailures = 0;\n  private openedAt = 0;\n  private probeInFlight = false;\n\n  constructor(\n    private readonly key: string,\n    private readonly config: CircuitBreakerConfig = DEFAULT_BREAKER_CONFIG,\n  ) {}\n\n  getState(): CircuitState {\n    return this.state;\n  }\n\n  /**\n   * Whether a request may proceed. Transitions open→half-open once the cooldown\n   * elapses and lets exactly ONE probe through. Returns false when open (or a\n   * probe is already in flight) — the caller must fast-fail without any network.\n   */\n  allowRequest(): boolean {\n    if (!this.config.enabled) return true;\n    if (this.state === 'closed') return true;\n    if (this.state === 'open') {\n      if (Date.now() - this.openedAt >= this.config.cooldownMs) {\n        this.state = 'half-open';\n        this.probeInFlight = true;\n        return true;\n      }\n      return false;\n    }\n    // half-open: allow only a single probe at a time.\n    if (this.probeInFlight) return false;\n    this.probeInFlight = true;\n    return true;\n  }\n\n  /** A logical request succeeded (2xx/3xx/4xx that isn't a downstream fault). */\n  recordSuccess(): void {\n    if (!this.config.enabled) return;\n    this.consecutiveFailures = 0;\n    this.probeInFlight = false;\n    if (this.state !== 'closed') {\n      logger.info('circuit closed (downstream recovered)', { target: this.key });\n      this.state = 'closed';\n    }\n  }\n\n  /** A logical request failed (connection error, timeout, or 5xx response). */\n  recordFailure(): void {\n    if (!this.config.enabled) return;\n    this.probeInFlight = false;\n    this.consecutiveFailures++;\n    // A failed half-open probe means the downstream is still bad — re-open.\n    if (this.state === 'half-open') {\n      this.open();\n      return;\n    }\n    if (this.state === 'closed' && this.consecutiveFailures >= this.config.failureThreshold) {\n      this.open();\n    }\n  }\n\n  private open(): void {\n    const wasOpen = this.state === 'open';\n    this.state = 'open';\n    this.openedAt = Date.now();\n    if (!wasOpen) {\n      logger.warn('circuit opened — shedding load to target', {\n        target: this.key,\n        consecutiveFailures: this.consecutiveFailures,\n        cooldownMs: this.config.cooldownMs,\n      });\n      emitCounter('s2s_circuit_opened_total', { target: this.key });\n    }\n  }\n}\n\nconst registry = new Map<string, CircuitBreaker>();\n\n/** Get (or lazily create) the shared breaker for a `host:port` target. */\nexport function getCircuitBreaker(key: string): CircuitBreaker {\n  let breaker = registry.get(key);\n  if (!breaker) {\n    breaker = new CircuitBreaker(key);\n    registry.set(key, breaker);\n  }\n  return breaker;\n}\n\n/** Test helper: clear all breaker state so suites don't leak across each other. */\nexport function resetCircuitBreakers(): void {\n  registry.clear();\n}\n\n/** Thrown by the client when a request is fast-failed because the breaker is open. */\nexport class CircuitOpenError extends Error {\n  readonly code = 'CIRCUIT_OPEN';\n  constructor(target: string) {\n    super(`Circuit open for ${target} — fast-failing to shed load`);\n    this.name = 'CircuitOpenError';\n  }\n}\n"]}

package/lib/services/compliance-client.d.ts

@@ -0,0 +1,46 @@
+import type { ServiceConfig } from '../types/common.js';
+/**
+ * Result of a compliance validation check.
+ */
+export interface ComplianceCheckResult {
+    passed: boolean;
+    violations: ComplianceViolation[];
+    warnings: ComplianceViolation[];
+    blocked: boolean;
+    rulesEvaluated: number;
+    rulesSkipped: number;
+    exemptionsApplied: string[];
+}
+export interface ComplianceViolation {
+    ruleId: string;
+    ruleName: string;
+    policyId?: string | null;
+    field: string;
+    operator: string;
+    expectedValue: unknown;
+    actualValue: unknown;
+    severity: string;
+    message: string;
+}
+/**
+ * Compliance service client interface.
+ * Uses fail-closed design: errors propagate to block the operation.
+ */
+export interface ComplianceClient {
+    /** Validate plugin attributes against org rules. Throws on service error (fail-closed). */
+    validatePlugin(orgId: string, attributes: Record<string, unknown>, authHeader: string, entityId?: string, entityName?: string, action?: string): Promise<ComplianceCheckResult>;
+    /** Validate pipeline attributes against org rules. Throws on service error (fail-closed). */
+    validatePipeline(orgId: string, attributes: Record<string, unknown>, authHeader: string, entityId?: string, entityName?: string, action?: string): Promise<ComplianceCheckResult>;
+    /** Pre-flight check for plugin (no audit, no notification). */
+    dryRunPlugin(orgId: string, attributes: Record<string, unknown>, authHeader: string): Promise<ComplianceCheckResult>;
+    /** Pre-flight check for pipeline (no audit, no notification). */
+    dryRunPipeline(orgId: string, attributes: Record<string, unknown>, authHeader: string): Promise<ComplianceCheckResult>;
+}
+/**
+ * Create a compliance client.
+ *
+ * IMPORTANT: This client is fail-closed — if the compliance service is
+ * unreachable or returns an error, the error propagates and the calling
+ * operation (plugin upload, pipeline create) is rejected.
+ */
+export declare function createComplianceClient(config?: Partial<ServiceConfig>): ComplianceClient;

package/lib/services/compliance-client.js

@@ -0,0 +1,128 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { InternalHttpClient } from './http-client.js';
+import { createLogger } from '../utils/logger.js';
+const logger = createLogger('compliance-client');
+/**
+ * When true, compliance checks are bypassed if the service is unavailable
+ * (fail-open). Default is fail-closed (errors propagate and block the operation).
+ */
+const COMPLIANCE_BYPASS = process.env.COMPLIANCE_BYPASS === 'true';
+/**
+ * Per-attempt timeout for a validation POST (env: `COMPLIANCE_VALIDATE_TIMEOUT_MS`).
+ * Deliberately TIGHTER than the 5s client default so the enforced retries (below)
+ * fit inside a bounded total budget rather than stacking three 5s stalls onto a
+ * single interactive request.
+ */
+const VALIDATE_TIMEOUT_MS = parseInt(process.env.COMPLIANCE_VALIDATE_TIMEOUT_MS ?? '4000', 10);
+/**
+ * Return a pass-through result when COMPLIANCE_BYPASS is enabled and the
+ * compliance service is unreachable.
+ */
+function bypassResult(context) {
+    logger.warn('COMPLIANCE_BYPASS: Service unavailable, allowing request', context);
+    return {
+        passed: true,
+        blocked: false,
+        violations: [],
+        warnings: [{ ruleId: '', ruleName: '', field: '', operator: '', expectedValue: null, actualValue: null, severity: 'warning', message: 'Compliance check skipped (service unavailable)' }],
+        rulesEvaluated: 0,
+        rulesSkipped: 0,
+        exemptionsApplied: [],
+    };
+}
+/**
+ * Build common request headers for compliance calls.
+ */
+function buildHeaders(orgId, authHeader) {
+    const headers = {
+        'x-org-id': orgId,
+    };
+    // NOTE: the old `x-internal-service: true` header was removed — it is trusted
+    // by nothing (it was spoofable); compliance routes authenticate the caller via
+    // the `Authorization` service JWT (`requireServicePrincipal`).
+    if (authHeader)
+        headers.Authorization = authHeader;
+    return headers;
+}
+/**
+ * Request options for a compliance validation POST.
+ *
+ * These calls are side-effect-free (they evaluate rules and return a verdict;
+ * any audit/notification the compliance service writes is derived, not a mutation
+ * the caller depends on being once-only), so they are marked `idempotent: true`.
+ * That lets the HTTP client auto-retry a transient 503 / connection reset /
+ * timeout instead of surfacing it as a hard failure — which, under the
+ * fail-closed default, would wrongly REJECT a legitimate plugin upload / pipeline
+ * create just because compliance briefly stalled. Paired with the tighter
+ * per-attempt timeout so the retries stay within a bounded total budget.
+ */
+function validateOptions(orgId, authHeader) {
+    return {
+        headers: buildHeaders(orgId, authHeader),
+        idempotent: true,
+        timeout: VALIDATE_TIMEOUT_MS,
+    };
+}
+/**
+ * Create a compliance client.
+ *
+ * IMPORTANT: This client is fail-closed — if the compliance service is
+ * unreachable or returns an error, the error propagates and the calling
+ * operation (plugin upload, pipeline create) is rejected.
+ */
+export function createComplianceClient(config) {
+    const serviceConfig = {
+        host: config?.host ?? process.env.COMPLIANCE_SERVICE_HOST ?? 'compliance',
+        port: config?.port ?? parseInt(process.env.COMPLIANCE_SERVICE_PORT ?? '3000', 10),
+    };
+    const client = new InternalHttpClient(serviceConfig);
+    /**
+     * Validate response shape + status. The HTTP client doesn't throw on non-2xx
+     * (it just returns the body), so without this an auth failure / route miss
+     * silently produced `response.body.data === undefined` and the caller
+     * crashed on `.blocked`. Now non-2xx surfaces as a thrown error that the
+     * outer try/catch can turn into either fail-closed (default) or
+     * COMPLIANCE_BYPASS (fail-open).
+     */
+    function unwrap(response, op) {
+        if (response.statusCode < 200 || response.statusCode >= 300) {
+            const msg = response.body?.message ?? `HTTP ${response.statusCode}`;
+            throw new Error(`compliance ${op} failed: ${msg}`);
+        }
+        if (!response.body?.data) {
+            throw new Error(`compliance ${op} returned no data (status ${response.statusCode})`);
+        }
+        return response.body.data;
+    }
+    // Shared body for all four validate/dry-run calls: POST → unwrap, and on a
+    // transport/HTTP failure either return a fail-open bypass result (when
+    // COMPLIANCE_BYPASS) or rethrow. The four methods differ ONLY in path, request
+    // body, op label, and bypass context.
+    async function runValidation(orgId, authHeader, path, body, op, bypassCtx) {
+        try {
+            const response = await client.post(path, body, validateOptions(orgId, authHeader));
+            return unwrap(response, op);
+        }
+        catch (error) {
+            if (COMPLIANCE_BYPASS)
+                return bypassResult(bypassCtx);
+            throw error;
+        }
+    }
+    return {
+        validatePlugin(orgId, attributes, authHeader, entityId, entityName, action) {
+            return runValidation(orgId, authHeader, '/compliance/validate/plugin', { attributes, entityId, entityName, action: action ?? 'upload' }, 'validatePlugin', { orgId, entityType: 'plugin', entityId, entityName });
+        },
+        validatePipeline(orgId, attributes, authHeader, entityId, entityName, action) {
+            return runValidation(orgId, authHeader, '/compliance/validate/pipeline', { attributes, entityId, entityName, action: action ?? 'create' }, 'validatePipeline', { orgId, entityType: 'pipeline', entityId, entityName });
+        },
+        dryRunPlugin(orgId, attributes, authHeader) {
+            return runValidation(orgId, authHeader, '/compliance/validate/plugin/dry-run', { attributes }, 'dryRunPlugin', { orgId, entityType: 'plugin', dryRun: true });
+        },
+        dryRunPipeline(orgId, attributes, authHeader) {
+            return runValidation(orgId, authHeader, '/compliance/validate/pipeline/dry-run', { attributes }, 'dryRunPipeline', { orgId, entityType: 'pipeline', dryRun: true });
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compliance-client.js","sourceRoot":"","sources":["../../src/services/compliance-client.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { InternalHttpClient, type RequestOptions } from './http-client.js';\nimport type { ServiceConfig } from '../types/common.js';\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('compliance-client');\n\n/**\n * When true, compliance checks are bypassed if the service is unavailable\n * (fail-open). Default is fail-closed (errors propagate and block the operation).\n */\nconst COMPLIANCE_BYPASS = process.env.COMPLIANCE_BYPASS === 'true';\n\n/**\n * Per-attempt timeout for a validation POST (env: `COMPLIANCE_VALIDATE_TIMEOUT_MS`).\n * Deliberately TIGHTER than the 5s client default so the enforced retries (below)\n * fit inside a bounded total budget rather than stacking three 5s stalls onto a\n * single interactive request.\n */\nconst VALIDATE_TIMEOUT_MS = parseInt(process.env.COMPLIANCE_VALIDATE_TIMEOUT_MS ?? '4000', 10);\n\n/**\n * Result of a compliance validation check.\n */\nexport interface ComplianceCheckResult {\n  passed: boolean;\n  violations: ComplianceViolation[];\n  warnings: ComplianceViolation[];\n  blocked: boolean;\n  rulesEvaluated: number;\n  rulesSkipped: number;\n  exemptionsApplied: string[];\n}\n\nexport interface ComplianceViolation {\n  ruleId: string;\n  ruleName: string;\n  policyId?: string | null;\n  field: string;\n  operator: string;\n  expectedValue: unknown;\n  actualValue: unknown;\n  severity: string;\n  message: string;\n}\n\n/**\n * Compliance service client interface.\n * Uses fail-closed design: errors propagate to block the operation.\n */\nexport interface ComplianceClient {\n  /** Validate plugin attributes against org rules. Throws on service error (fail-closed). */\n  validatePlugin(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n    entityId?: string,\n    entityName?: string,\n    action?: string,\n  ): Promise<ComplianceCheckResult>;\n\n  /** Validate pipeline attributes against org rules. Throws on service error (fail-closed). */\n  validatePipeline(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n    entityId?: string,\n    entityName?: string,\n    action?: string,\n  ): Promise<ComplianceCheckResult>;\n\n  /** Pre-flight check for plugin (no audit, no notification). */\n  dryRunPlugin(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n  ): Promise<ComplianceCheckResult>;\n\n  /** Pre-flight check for pipeline (no audit, no notification). */\n  dryRunPipeline(\n    orgId: string,\n    attributes: Record<string, unknown>,\n    authHeader: string,\n  ): Promise<ComplianceCheckResult>;\n}\n\n/**\n * Return a pass-through result when COMPLIANCE_BYPASS is enabled and the\n * compliance service is unreachable.\n */\nfunction bypassResult(context: Record<string, unknown>): ComplianceCheckResult {\n  logger.warn('COMPLIANCE_BYPASS: Service unavailable, allowing request', context);\n  return {\n    passed: true,\n    blocked: false,\n    violations: [],\n    warnings: [{ ruleId: '', ruleName: '', field: '', operator: '', expectedValue: null, actualValue: null, severity: 'warning', message: 'Compliance check skipped (service unavailable)' }],\n    rulesEvaluated: 0,\n    rulesSkipped: 0,\n    exemptionsApplied: [],\n  };\n}\n\n/**\n * Build common request headers for compliance calls.\n */\nfunction buildHeaders(orgId: string, authHeader: string): Record<string, string> {\n  const headers: Record<string, string> = {\n    'x-org-id': orgId,\n  };\n  // NOTE: the old `x-internal-service: true` header was removed — it is trusted\n  // by nothing (it was spoofable); compliance routes authenticate the caller via\n  // the `Authorization` service JWT (`requireServicePrincipal`).\n  if (authHeader) headers.Authorization = authHeader;\n  return headers;\n}\n\n/**\n * Request options for a compliance validation POST.\n *\n * These calls are side-effect-free (they evaluate rules and return a verdict;\n * any audit/notification the compliance service writes is derived, not a mutation\n * the caller depends on being once-only), so they are marked `idempotent: true`.\n * That lets the HTTP client auto-retry a transient 503 / connection reset /\n * timeout instead of surfacing it as a hard failure — which, under the\n * fail-closed default, would wrongly REJECT a legitimate plugin upload / pipeline\n * create just because compliance briefly stalled. Paired with the tighter\n * per-attempt timeout so the retries stay within a bounded total budget.\n */\nfunction validateOptions(orgId: string, authHeader: string): RequestOptions {\n  return {\n    headers: buildHeaders(orgId, authHeader),\n    idempotent: true,\n    timeout: VALIDATE_TIMEOUT_MS,\n  };\n}\n\n/**\n * Create a compliance client.\n *\n * IMPORTANT: This client is fail-closed — if the compliance service is\n * unreachable or returns an error, the error propagates and the calling\n * operation (plugin upload, pipeline create) is rejected.\n */\nexport function createComplianceClient(config?: Partial<ServiceConfig>): ComplianceClient {\n  const serviceConfig: ServiceConfig = {\n    host: config?.host ?? process.env.COMPLIANCE_SERVICE_HOST ?? 'compliance',\n    port: config?.port ?? parseInt(process.env.COMPLIANCE_SERVICE_PORT ?? '3000', 10),\n  };\n\n  const client = new InternalHttpClient(serviceConfig);\n\n  /**\n   * Validate response shape + status. The HTTP client doesn't throw on non-2xx\n   * (it just returns the body), so without this an auth failure / route miss\n   * silently produced `response.body.data === undefined` and the caller\n   * crashed on `.blocked`. Now non-2xx surfaces as a thrown error that the\n   * outer try/catch can turn into either fail-closed (default) or\n   * COMPLIANCE_BYPASS (fail-open).\n   */\n  function unwrap(\n    response: { statusCode: number; body: { success?: boolean; data?: ComplianceCheckResult; message?: string } },\n    op: string,\n  ): ComplianceCheckResult {\n    if (response.statusCode < 200 || response.statusCode >= 300) {\n      const msg = response.body?.message ?? `HTTP ${response.statusCode}`;\n      throw new Error(`compliance ${op} failed: ${msg}`);\n    }\n    if (!response.body?.data) {\n      throw new Error(`compliance ${op} returned no data (status ${response.statusCode})`);\n    }\n    return response.body.data;\n  }\n\n  // Shared body for all four validate/dry-run calls: POST → unwrap, and on a\n  // transport/HTTP failure either return a fail-open bypass result (when\n  // COMPLIANCE_BYPASS) or rethrow. The four methods differ ONLY in path, request\n  // body, op label, and bypass context.\n  async function runValidation(\n    orgId: string,\n    authHeader: string,\n    path: string,\n    body: Record<string, unknown>,\n    op: string,\n    bypassCtx: Record<string, unknown>,\n  ): Promise<ComplianceCheckResult> {\n    try {\n      const response = await client.post<{ success: boolean; data: ComplianceCheckResult; message?: string }>(\n        path, body, validateOptions(orgId, authHeader),\n      );\n      return unwrap(response, op);\n    } catch (error) {\n      if (COMPLIANCE_BYPASS) return bypassResult(bypassCtx);\n      throw error;\n    }\n  }\n\n  return {\n    validatePlugin(orgId, attributes, authHeader, entityId, entityName, action) {\n      return runValidation(orgId, authHeader, '/compliance/validate/plugin',\n        { attributes, entityId, entityName, action: action ?? 'upload' }, 'validatePlugin',\n        { orgId, entityType: 'plugin', entityId, entityName });\n    },\n\n    validatePipeline(orgId, attributes, authHeader, entityId, entityName, action) {\n      return runValidation(orgId, authHeader, '/compliance/validate/pipeline',\n        { attributes, entityId, entityName, action: action ?? 'create' }, 'validatePipeline',\n        { orgId, entityType: 'pipeline', entityId, entityName });\n    },\n\n    dryRunPlugin(orgId, attributes, authHeader) {\n      return runValidation(orgId, authHeader, '/compliance/validate/plugin/dry-run',\n        { attributes }, 'dryRunPlugin', { orgId, entityType: 'plugin', dryRun: true });\n    },\n\n    dryRunPipeline(orgId, attributes, authHeader) {\n      return runValidation(orgId, authHeader, '/compliance/validate/pipeline/dry-run',\n        { attributes }, 'dryRunPipeline', { orgId, entityType: 'pipeline', dryRun: true });\n    },\n  };\n}\n"]}

package/lib/services/compliance-event-subscriber.d.ts

@@ -0,0 +1,16 @@
+import { type ServiceConfig } from '../types/common.js';
+/**
+ * Registers an entity event subscriber that forwards events to the compliance service.
+ *
+ * Call this at service startup (in index.ts) to enable automatic compliance
+ * notification on entity mutations. Events are fire-and-forget — failures
+ * are logged but never block the original request.
+ *
+ * @param config - Optional service config override (defaults to COMPLIANCE_SERVICE_HOST/PORT env vars)
+ * @param serviceName - Service identifier baked into the signed JWT's `sub`
+ *   (e.g. 'pipeline', 'plugin'). The compliance route requires a service
+ *   principal — a spoofable `x-internal-service: true` header is no longer
+ *   accepted. Defaults to a generic 'entity-events' when unspecified, but
+ *   callers should pass their service name for accurate audit trails.
+ */
+export declare function registerComplianceEventSubscriber(config?: Partial<ServiceConfig>, serviceName?: string): void;

package/lib/services/compliance-event-subscriber.js

@@ -0,0 +1,72 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { entityEvents } from './entity-events.js';
+import { InternalHttpClient } from './http-client.js';
+import { getServiceAuthHeader } from '../middleware/auth.js';
+import {} from '../types/common.js';
+import { createLogger } from '../utils/logger.js';
+import { emitCounter } from '../utils/metric-emitter.js';
+const logger = createLogger('compliance-events');
+/**
+ * Registers an entity event subscriber that forwards events to the compliance service.
+ *
+ * Call this at service startup (in index.ts) to enable automatic compliance
+ * notification on entity mutations. Events are fire-and-forget — failures
+ * are logged but never block the original request.
+ *
+ * @param config - Optional service config override (defaults to COMPLIANCE_SERVICE_HOST/PORT env vars)
+ * @param serviceName - Service identifier baked into the signed JWT's `sub`
+ *   (e.g. 'pipeline', 'plugin'). The compliance route requires a service
+ *   principal — a spoofable `x-internal-service: true` header is no longer
+ *   accepted. Defaults to a generic 'entity-events' when unspecified, but
+ *   callers should pass their service name for accurate audit trails.
+ */
+export function registerComplianceEventSubscriber(config, serviceName = 'entity-events') {
+    const serviceConfig = {
+        host: config?.host ?? process.env.COMPLIANCE_SERVICE_HOST ?? 'compliance',
+        port: config?.port ?? parseInt(process.env.COMPLIANCE_SERVICE_PORT ?? '3000', 10),
+    };
+    const client = new InternalHttpClient(serviceConfig);
+    const subscriber = {
+        async onEntityEvent(event) {
+            try {
+                // Mint a per-event service JWT scoped to the event's org so the
+                // compliance route's `runWithTenantContext` sees the right tenant
+                // GUC. The compliance side enforces `requireAuth` +
+                // `requireServicePrincipal` — the previous `x-internal-service`
+                // header is no longer sufficient (and was spoofable).
+                //
+                // This HTTP notify is the SINGLE delivery channel for post-mutation
+                // re-validation (primary enforcement is the fail-CLOSED live
+                // validate path). A stable per-event `Idempotency-Key` makes the POST
+                // retry-safe in the http-client, so a transient 5xx/timeout is retried
+                // rather than dropped on the first attempt; compliance re-evaluation is
+                // naturally idempotent, so a duplicate delivery is harmless.
+                await client.post('/compliance/events/entity', event, {
+                    headers: {
+                        'Authorization': getServiceAuthHeader({ serviceName, orgId: event.orgId, role: 'member' }),
+                        'Idempotency-Key': `${event.target}:${event.entityId}:${event.eventType}:${event.timestamp.toISOString()}`,
+                    },
+                });
+            }
+            catch (err) {
+                // Fire-and-forget: log + a drop metric so sustained loss is alertable
+                // (operators can't act on a warn line alone), then swallow — compliance
+                // notification is non-fatal to the originating mutation.
+                emitCounter('compliance_event_drop_total', { service: serviceName, target: event.target });
+                logger.warn('Failed to notify compliance service of entity event', {
+                    target: event.target,
+                    eventType: event.eventType,
+                    entityId: event.entityId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        },
+    };
+    entityEvents.subscribe(subscriber);
+    logger.info('Compliance event subscriber registered', {
+        host: serviceConfig.host,
+        port: serviceConfig.port,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/services/durable-event-bus.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Durable, at-least-once event backbone (Redis Streams).
+ *
+ * The platform's cross-service signalling today is point-to-point HTTP plus
+ * polling reconcilers plus an IN-PROCESS best-effort emitter ({@link entityEvents}).
+ * There is no durable bus, so a signal produced on one pod is either delivered
+ * synchronously over HTTP (coupling + retry-storm risk) or lost if the consumer
+ * is momentarily down (the reconcilers exist to paper over exactly that).
+ *
+ * This is that missing bus, as a reusable primitive:
+ *  - **publish(topic, payload)** → `XADD` onto a bounded (`MAXLEN ~`) per-topic
+ *    stream. Durable across restarts, shared by all replicas.
+ *  - **subscribe({topic, group, consumer, handler})** → a `XREADGROUP` consumer.
+ *    Consumer GROUPS give at-least-once: each group gets every message once, a
+ *    message stays pending until the handler `XACK`s it, and `XAUTOCLAIM`
+ *    reclaims messages stranded by a crashed consumer. Multiple groups on one
+ *    topic = independent fan-out (e.g. quota-sync AND audit both react).
+ *
+ * FAIL-SAFE + OPT-IN, exactly like the audit spool: {@link createEnvRedisDurableEventBus}
+ * returns `null` when Redis isn't configured, so a service without it simply
+ * doesn't use the bus (keeps today's behavior). A publish failure is dropped-with-
+ * -metric, never thrown; a handler throw leaves the message un-acked for redelivery.
+ *
+ * Migrating a specific reconciler (e.g. billing→quota entitlement sync) onto this
+ * is deliberately follow-on work — this lands the backbone + an additive entity-
+ * event bridge; the reconcilers stay as the belt-and-suspenders backstop until a
+ * flow is fully cut over.
+ */
+import type { EntityEventSubscriber } from './entity-events.js';
+/** A delivered event: its stream id, topic, and decoded payload. */
+export interface EventEnvelope<T = unknown> {
+    /** Redis Stream entry id (`<ms>-<seq>`) — also the idempotency handle. */
+    id: string;
+    topic: string;
+    payload: T;
+}
+export interface SubscribeOptions<T = unknown> {
+    /** Topic (stream) to consume. */
+    topic: string;
+    /** Consumer group — one delivery per group; distinct groups fan out. */
+    group: string;
+    /** This consumer's id within the group (e.g. `${service}-${pid}`). */
+    consumer: string;
+    /** Async handler. Resolves ⇒ the message is acked; throws ⇒ left pending for redelivery. */
+    handler: (env: EventEnvelope<T>) => Promise<void>;
+    /** Max messages per read (default 16). */
+    batchSize?: number;
+    /** XREADGROUP block time in ms (default 5000). */
+    blockMs?: number;
+    /** A pending message idle this long (ms) is reclaimed from a dead consumer (default 60000). */
+    minIdleMs?: number;
+}
+export interface EventSubscription {
+    /** Stop the consumer loop. Resolves once the in-flight read returns. */
+    stop(): Promise<void>;
+}
+export interface DurableEventBus {
+    /** Publish a payload to a topic. Returns the stream id, or null on failure (dropped, never throws). */
+    publish<T>(topic: string, payload: T): Promise<string | null>;
+    /** Start a consumer-group reader for a topic. Fire-and-forget loop; call `stop()` to end it. */
+    subscribe<T>(opts: SubscribeOptions<T>): EventSubscription;
+}
+/**
+ * The subset of ioredis' Stream API the bus uses. Kept minimal so a test can
+ * supply an in-memory fake and so merely importing this never hard-depends on
+ * ioredis (constructed via the shared env helper).
+ */
+export interface RedisStreamClient {
+    xadd(key: string, ...args: (string | number)[]): Promise<string | null>;
+    xgroup(...args: (string | number)[]): Promise<unknown>;
+    xreadgroup(...args: (string | number)[]): Promise<unknown>;
+    xack(key: string, group: string, ...ids: string[]): Promise<number>;
+    xautoclaim(...args: (string | number)[]): Promise<unknown>;
+}
+/** Build a durable event bus over a Redis Streams client. */
+export declare function createRedisDurableEventBus(redis: RedisStreamClient, opts?: {
+    maxLen?: number;
+}): DurableEventBus;
+/**
+ * Build a durable event bus from the ambient Redis env via the shared
+ * `createEnvRedisClient`. Returns `null` when Redis is not configured — the
+ * caller then runs without a bus (today's HTTP/reconciler behavior), never
+ * crashing. Opt in with a single boot line where a service wants durable events.
+ */
+export declare function createEnvRedisDurableEventBus(opts?: {
+    maxLen?: number;
+}): DurableEventBus | null;
+/** Topic the entity-event bridge publishes to. */
+export declare const ENTITY_EVENT_TOPIC = "entity-events";
+/**
+ * An {@link EntityEventSubscriber} that forwards each entity event to the durable
+ * bus. `bus.publish` is fail-safe (drops-with-metric, never throws), matching the
+ * emitter's fire-and-forget contract. Note `EntityEvent.timestamp` (a Date)
+ * serializes to an ISO string on the wire — a consumer re-hydrates as needed.
+ */
+export declare function createEntityEventBusPublisher(bus: DurableEventBus): EntityEventSubscriber;