@pipeline-builder/api-core 5.2.2 → 5.2.4

package/lib/services/remote-audit-client.d.ts

@@ -4,7 +4,20 @@ export interface RemoteAuditEvent {
     action: RemoteAuditAction;
     actorId: string;
     actorEmail?: string;
-    orgId?: string;
+    /**
+     * The org the event is recorded FOR — REQUIRED. The platform ingest binds every
+     * event to the service token's org, and the client mints that token with this
+     * value, so an org-less event can never be stored (it used to be refused 403
+     * "no org claim" and then wedge the spool). System work with no tenant passes
+     * `SYSTEM_ORG_ID` explicitly — e.g. a registry GC sweep.
+     */
+    orgId: string;
+    /**
+     * The org the action touched, when it is NOT `orgId` (the system org acting on
+     * a publisher's plugin, a superadmin purging a tenant's pipeline). Accepted
+     * cross-org only from a system-org token, or when the inbound principal was a
+     * superadmin / system-org member (see `auditCrossOrg` in the ingest).
+     */
     affectedOrgId?: string;
     targetType?: string;
     targetId?: string;
@@ -28,8 +41,38 @@ export interface RemoteAuditEvent {
      * copy so a live attempt and its later re-delivery collapse to ONE stored row.
      */
     idempotencyKey?: string;
+    /**
+     * Correlation context. Normally left unset: `record()` fills each from the
+     * ambient audit context (see `runWithAuditContext`) — the inbound request's id,
+     * trace id, client ip and user agent. Set one only to override it.
+     *
+     * An ANONYMOUS actor never inherits the client ip / user agent from context:
+     * those rows are the public, unauthenticated surfaces (plugin submissions,
+     * report verify/unsubscribe) whose callers deliberately record only a HASHED
+     * ip/address — stamping the raw ip beside it would undo that. Pass `ip` /
+     * `userAgent` explicitly if an anonymous row genuinely needs them.
+     */
+    requestId?: string;
+    traceId?: string;
+    ip?: string;
+    userAgent?: string;
+    /**
+     * Free-form event detail. Keep it free of secrets/tokens, PII and AWS account
+     * ids. The keys `_auth` and `_context` are RESERVED: `record()` replaces them
+     * with the verified credential block and the correlation/job ids from the
+     * ambient audit context, whatever the call site passed.
+     */
     details?: Record<string, unknown>;
 }
+/**
+ * The event as it goes over the wire and into the spool: the call-site event
+ * plus what `record()` stamps from the ambient audit context. `impersonatorId` is
+ * NOT a call-site field — it comes only from the inbound request's verified
+ * token, so no route can attribute an action to an impersonator by passing one.
+ */
+export interface RemoteAuditWireEvent extends RemoteAuditEvent {
+    impersonatorId?: string;
+}
 /**
  * Client for POSTing audit events to the platform's `/audit-events` ingest
  * endpoint. Mints a fresh service token per call (5 min TTL)  there's no

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

@@ -1,11 +1,14 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import { randomUUID } from 'crypto';
+import { auditAuthBlock, currentAuditContext } from './audit-context.js';
 import { auditSpoolKey, createEnvRedisAuditSpool } from './audit-spool.js';
 import { createSafeClient } from './http-client.js';
 import { setAuthzDenialAuditor } from '../middleware/permission-gates.js';
 import { getServiceAuthHeader } from '../middleware/service-tokens.js';
+import { SYSTEM_ORG_ID } from '../middleware/system-org.js';
 import {} from '../types/remote-audit-actions.js';
+import { ANONYMOUS_ACTOR_ID } from '../utils/identity.js';
 import { createLogger } from '../utils/logger.js';
 import { emitCounter } from '../utils/metric-emitter.js';
 import { errorMessage } from '../utils/response.js';
@@ -24,6 +27,49 @@ const AUDIT_REQUEST_OPTIONS = {
     maxRateLimitRetries: 2,
     maxRetries: 2,
 };
+/** `details` keys only `record()` may write (see {@link RemoteAuditEvent.details}). */
+const RESERVED_DETAIL_KEYS = ['_auth', '_context'];
+/**
+ * Stamp an event with the ambient audit context at the moment it is RECORDED.
+ * Persisted on the event, so a spooled re-delivery carries the original
+ * request's context rather than whatever is ambient when the drain runs.
+ */
+function stampAuditContext(event) {
+    const ctx = currentAuditContext();
+    const principal = ctx?.principal?.();
+    const auth = auditAuthBlock(principal);
+    const context = { ...ctx?.correlation, ...ctx?.job };
+    const anonymous = event.actorId === ANONYMOUS_ACTOR_ID;
+    const details = { ...event.details };
+    for (const key of RESERVED_DETAIL_KEYS)
+        delete details[key];
+    if (auth)
+        details._auth = auth;
+    if (Object.keys(context).length > 0)
+        details._context = context;
+    return {
+        ...event,
+        requestId: event.requestId ?? ctx?.requestId,
+        traceId: event.traceId ?? ctx?.traceId,
+        ip: event.ip ?? (anonymous ? undefined : ctx?.ip),
+        userAgent: event.userAgent ?? (anonymous ? undefined : ctx?.userAgent),
+        ...(principal?.impersonatorId ? { impersonatorId: principal.impersonatorId } : {}),
+        ...(Object.keys(details).length > 0 ? { details } : { details: undefined }),
+    };
+}
+/**
+ * Whether this event may name an `affectedOrgId` outside its own org. Derived
+ * ONLY from the stamped `_auth` block (the verified inbound principal), which
+ * `record()` always overwrites — a call site cannot grant it.
+ */
+function crossOrgAuthorized(event) {
+    if (!event.affectedOrgId || event.affectedOrgId === event.orgId)
+        return false;
+    const auth = event.details?._auth;
+    return auth?.superAdmin === true || auth?.systemOrg === true;
+}
+/** 4xx statuses that are transient, not a verdict on the event. */
+const RETRYABLE_4XX = new Set([408, 429]);
 /**
  * Construct a remote-audit client targeted at the platform service.
  *
@@ -75,23 +121,49 @@ export function createRemoteAuditClient(config = {}) {
             // the rejection would go unhandled and crash-loop the pod on its first
             // audited write. Inside, a key problem is just an undeliverable event:
             // spooled, or dropped and metered.
-            const authHeader = getServiceAuthHeader({ serviceName, orgId: event.orgId, role: 'member' });
+            const authHeader = getServiceAuthHeader({
+                serviceName,
+                orgId: event.orgId,
+                role: 'member',
+                ...(crossOrgAuthorized(event) ? { auditCrossOrg: true } : {}),
+            });
             const headers = {
                 'Authorization': authHeader,
                 'Idempotency-Key': event.idempotencyKey ?? randomUUID(),
             };
             const response = await client.post('/audit/events', event, { headers, ...AUDIT_REQUEST_OPTIONS });
-            const ok = !!response && response.statusCode >= 200 && response.statusCode < 300;
-            if (!ok) {
-                logger.warn('Remote audit ingest non-ok', { action: event.action, statusCode: response?.statusCode });
+            const status = response?.statusCode;
+            if (status !== undefined && status >= 200 && status < 300)
+                return { kind: 'delivered' };
+            if (status !== undefined && status >= 400 && status < 500 && !RETRYABLE_4XX.has(status)) {
+                return { kind: 'rejected', status };
             }
-            return ok;
+            logger.warn('Remote audit ingest non-ok', { action: event.action, statusCode: status });
+            return { kind: 'retry' };
         }
         catch (err) {
             logger.warn('Remote audit ingest threw', { action: event.action, error: errorMessage(err) });
-            return false;
+            return { kind: 'retry' };
         }
     }
+    /**
+     * A permanently refused event is DROPPED — loudly. Spooling it would put it at
+     * the head of the queue forever (the drain stops at the first failure), so one
+     * malformed event would silently stall every later event this service emits.
+     * `AuditEventsRejected` pages on the counter.
+     */
+    function reportRejected(event, serviceName, status) {
+        emitCounter('audit_events_rejected_total', { service: serviceName, status: String(status) });
+        logger.error('Remote audit event REJECTED by ingest (dropped, not retried)', {
+            action: event.action,
+            statusCode: status,
+            orgId: event.orgId,
+            affectedOrgId: event.affectedOrgId,
+            targetType: event.targetType,
+            targetId: event.targetId,
+            requestId: event.requestId,
+        });
+    }
     // Serialize spool drains so a periodic tick and an on-success drain can't both
     // pull the same batch. Stops early the moment a re-delivery fails (platform
     // still down) so we don't hammer it or churn the buffer.
@@ -105,7 +177,9 @@ export function createRemoteAuditClient(config = {}) {
                 const batch = await spool.take(drainBatchSize);
                 if (batch.length === 0)
                     return;
-                const delivered = [];
+                // `settled` = delivered OR permanently rejected: either way it leaves the
+                // spool. Only a retryable failure stops the sweep and goes back.
+                const settled = [];
                 const failed = [];
                 let platformDown = false;
                 for (const entry of batch) {
@@ -113,21 +187,25 @@ export function createRemoteAuditClient(config = {}) {
                         failed.push(entry);
                         continue;
                     }
-                    const ok = await deliver(entry.event, entry.serviceName);
-                    if (ok) {
-                        delivered.push(entry);
+                    const result = await deliver(entry.event, entry.serviceName);
+                    if (result.kind === 'delivered') {
+                        settled.push(entry);
                         emitCounter('audit_spool_redelivered_total', { service: entry.serviceName });
                     }
+                    else if (result.kind === 'rejected') {
+                        settled.push(entry);
+                        reportRejected(entry.event, entry.serviceName, result.status);
+                    }
                     else {
                         platformDown = true;
                         failed.push(entry);
                     }
                 }
-                // Acknowledge the delivered prefix so it clears the in-progress list; the
+                // Acknowledge the settled entries so they clear the in-progress list; the
                 // reliable take() moved the whole batch there, so unacked survivors are
                 // reclaimed by recover() after a crash rather than being silently lost.
-                if (delivered.length > 0)
-                    await spool.ack(delivered);
+                if (settled.length > 0)
+                    await spool.ack(settled);
                 if (failed.length > 0) {
                     await spool.requeue(failed);
                     return; // still down — try again on the next tick
@@ -156,19 +234,23 @@ export function createRemoteAuditClient(config = {}) {
     }
     return {
         record(event, serviceName) {
-            // Stamp when the action actually occurred (survives spool delay) and pin a
-            // stable idempotency key so a live attempt and its spooled retry dedup.
+            // Stamp the ambient request/job context and when the action actually
+            // occurred (all survive spool delay), and pin a stable idempotency key so a
+            // live attempt and its spooled retry dedup.
             const stamped = {
-                ...event,
+                ...stampAuditContext(event),
                 occurredAt: event.occurredAt ?? new Date().toISOString(),
                 idempotencyKey: event.idempotencyKey ?? randomUUID(),
             };
-            void deliver(stamped, serviceName).then((ok) => {
-                if (ok) {
+            void deliver(stamped, serviceName).then((result) => {
+                if (result.kind === 'delivered') {
                     emitCounter('audit_emitted_total', { service: serviceName, outcome: stamped.outcome ?? 'success' });
                     if (spool)
                         void drain(); // platform is reachable — flush any backlog
                 }
+                else if (result.kind === 'rejected') {
+                    reportRejected(stamped, serviceName, result.status);
+                }
                 else if (spool) {
                     void spool.enqueue({ event: stamped, serviceName });
                 }
@@ -208,11 +290,15 @@ export function createRemoteAuditClient(config = {}) {
  * a RemoteAuditClient.
  */
 export function wireAuthzDenialAuditor(serviceName, getClient) {
+    // Request context (ip / user agent / request id / credential / impersonator)
+    // is stamped by `record()` from the ambient audit context — the denial fires
+    // inside the request's scope. An unauthenticated denial has no org: it is
+    // recorded on the system org's chain rather than refused for lacking one.
     setAuthzDenialAuditor((info) => getClient().record({
         action: 'authz.denied',
         actorId: info.actorId ?? 'anonymous',
         actorEmail: info.actorEmail,
-        orgId: info.orgId,
+        orgId: info.orgId ?? SYSTEM_ORG_ID,
         outcome: 'failure',
         details: { method: info.method, path: info.path, required: info.required },
     }, serviceName));
@@ -272,4 +358,4 @@ export function recordAudit(event) {
     const { client, serviceName } = boundAudit();
     client.record(event, serviceName);
 }
-//# 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 { auditSpoolKey, createEnvRedisAuditSpool, type AuditSpool, type AuditSpoolEntry } from './audit-spool.js';\nimport { createSafeClient, type RequestOptions } from './http-client.js';\nimport { setAuthzDenialAuditor, type AuthzDenialInfo } from '../middleware/permission-gates.js';\nimport { getServiceAuthHeader } from '../middleware/service-tokens.js';\nimport type { ServiceConfig } from '../types/common.js';\nimport { type RemoteAuditAction } from '../types/remote-audit-actions.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { errorMessage } from '../utils/response.js';\nimport { serviceEndpoint } from '../utils/service-registry.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\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 ?? serviceEndpoint('platform').host,\n    port: config.port ?? serviceEndpoint('platform').port,\n    timeout: config.timeout ?? 3000,\n  };\n  // Its own breaker route class: audit ingest failing (5xx while platform's\n  // audit store is degraded) must not open the breaker that platform's JWKS and\n  // key-exchange calls ride on — that would turn an audit brownout into an auth\n  // outage in every service.\n  const client = createSafeClient(serviceConfig, { breakerClass: 'audit' });\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    try {\n      // Minting the token is INSIDE the try on purpose. It can throw — the\n      // signing key unreadable, not an EC P-256 key, or `SERVICE_NAME` not\n      // matching this client's name. Outside the `try`, `deliver` would reject\n      // instead of resolving `false`; `record` fires it with a bare `.then`, so\n      // the rejection would go unhandled and crash-loop the pod on its first\n      // audited write. Inside, a key problem is just an undeliverable event:\n      // spooled, or dropped and metered.\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      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: errorMessage(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: errorMessage(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    // Every tick: heartbeat (so peers never reclaim a batch this pod is still\n    // delivering — even mid-drain), reclaim batches of pods that died, drain.\n    drainTimer = setInterval(() => {\n      void spool.heartbeat().then(() => spool.recover()).then(() => drain());\n    }, 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      }).catch((err) => {\n        // Belt and braces. `deliver` never rejects, but anything that throws\n        // in the continuation would otherwise become an unhandled rejection —\n        // and in this process that is a crash, not a log line. An audit event\n        // must never take the service down.\n        emitCounter('audit_dropped_total', { service: serviceName });\n        logger.error('Remote audit record failed unexpectedly', { action: stamped.action, error: errorMessage(err) });\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 * The process-wide remote-audit binding: which service this process is, and the\n * (lazily built) client its events go through. Bound ONCE at boot by\n * `wireServiceSecurity(serviceName)` — every stateless service calls it — so the\n * service identity is never repeated at a call site and can never drift.\n */\ninterface AuditBinding {\n  serviceName: string;\n  client: RemoteAuditClient | null;\n}\n\nlet auditBinding: AuditBinding | null = null;\n\n/**\n * Bind this process's service identity for {@link recordAudit}. Called by\n * `wireServiceSecurity`; tests go through `bindTestAuditService`\n * (`@pipeline-builder/api-core/testing`), which passes a spy `client`.\n *\n * Without `client`, the real one is built lazily on first emission: a\n * RemoteAuditClient wired to the durable env-Redis spool (null → no spool).\n * Lazy on purpose — building it at boot would force the spool's Redis connection\n * wherever the service module is merely imported. Rebinding closes the previous\n * client's spool-drain timer.\n */\nexport function bindAuditService(serviceName: string, client?: RemoteAuditClient): void {\n  auditBinding?.client?.close();\n  auditBinding = { serviceName, client: client ?? null };\n}\n\n/** Drop the binding (tests only — returns the process to the unbound state). */\nexport function unbindAuditService(): void {\n  auditBinding?.client?.close();\n  auditBinding = null;\n}\n\nfunction boundAudit(): AuditBinding & { client: RemoteAuditClient } {\n  if (!auditBinding) {\n    throw new Error('audit not initialised: call wireServiceSecurity(serviceName) at boot before recordAudit()');\n  }\n  auditBinding.client ??= createRemoteAuditClient({\n    spool: createEnvRedisAuditSpool({ key: auditSpoolKey(auditBinding.serviceName) }) ?? undefined,\n  });\n  return auditBinding as AuditBinding & { client: RemoteAuditClient };\n}\n\n/**\n * The bound service's RemoteAuditClient. Throws \"audit not initialised\" before\n * `wireServiceSecurity` has run. Internal: callers emit through\n * {@link recordAudit}; `wireServiceSecurity` hands this getter to the\n * `authz.denied` sink.\n */\nexport function getBoundAuditClient(): RemoteAuditClient {\n  return boundAudit().client;\n}\n\n/**\n * Record an event in the durable, hash-chained central audit trail (platform's\n * `POST /audit/events` ingest), attributed to the service bound at boot.\n *\n * FIRE-AND-FORGET: delivery never blocks or throws — emit only AFTER the\n * mutation succeeds, and keep `details` free of secrets/tokens, PII and AWS\n * account ids. The ONE thing that throws is calling it before\n * `wireServiceSecurity(serviceName)` has bound the service: that is a wiring\n * bug, and failing loudly beats silently attributing the event to nobody.\n *\n * (The winston/Loki log line is a different sink: `logAuditEvent`.)\n */\nexport function recordAudit(event: RemoteAuditEvent): void {\n  const { client, serviceName } = boundAudit();\n  client.record(event, serviceName);\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 { auditAuthBlock, currentAuditContext } from './audit-context.js';\nimport { auditSpoolKey, createEnvRedisAuditSpool, type AuditSpool, type AuditSpoolEntry } from './audit-spool.js';\nimport { createSafeClient, type RequestOptions } from './http-client.js';\nimport { setAuthzDenialAuditor, type AuthzDenialInfo } from '../middleware/permission-gates.js';\nimport { getServiceAuthHeader } from '../middleware/service-tokens.js';\nimport { SYSTEM_ORG_ID } from '../middleware/system-org.js';\nimport type { ServiceConfig } from '../types/common.js';\nimport { type RemoteAuditAction } from '../types/remote-audit-actions.js';\nimport { ANONYMOUS_ACTOR_ID } from '../utils/identity.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { errorMessage } from '../utils/response.js';\nimport { serviceEndpoint } from '../utils/service-registry.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\nexport interface RemoteAuditEvent {\n  action: RemoteAuditAction;\n  actorId: string;\n  actorEmail?: string;\n  /**\n   * The org the event is recorded FOR — REQUIRED. The platform ingest binds every\n   * event to the service token's org, and the client mints that token with this\n   * value, so an org-less event can never be stored (it used to be refused 403\n   * \"no org claim\" and then wedge the spool). System work with no tenant passes\n   * `SYSTEM_ORG_ID` explicitly — e.g. a registry GC sweep.\n   */\n  orgId: string;\n  /**\n   * The org the action touched, when it is NOT `orgId` (the system org acting on\n   * a publisher's plugin, a superadmin purging a tenant's pipeline). Accepted\n   * cross-org only from a system-org token, or when the inbound principal was a\n   * superadmin / system-org member (see `auditCrossOrg` in the ingest).\n   */\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  /**\n   * Correlation context. Normally left unset: `record()` fills each from the\n   * ambient audit context (see `runWithAuditContext`) — the inbound request's id,\n   * trace id, client ip and user agent. Set one only to override it.\n   *\n   * An ANONYMOUS actor never inherits the client ip / user agent from context:\n   * those rows are the public, unauthenticated surfaces (plugin submissions,\n   * report verify/unsubscribe) whose callers deliberately record only a HASHED\n   * ip/address — stamping the raw ip beside it would undo that. Pass `ip` /\n   * `userAgent` explicitly if an anonymous row genuinely needs them.\n   */\n  requestId?: string;\n  traceId?: string;\n  ip?: string;\n  userAgent?: string;\n  /**\n   * Free-form event detail. Keep it free of secrets/tokens, PII and AWS account\n   * ids. The keys `_auth` and `_context` are RESERVED: `record()` replaces them\n   * with the verified credential block and the correlation/job ids from the\n   * ambient audit context, whatever the call site passed.\n   */\n  details?: Record<string, unknown>;\n}\n\n/**\n * The event as it goes over the wire and into the spool: the call-site event\n * plus what `record()` stamps from the ambient audit context. `impersonatorId` is\n * NOT a call-site field — it comes only from the inbound request's verified\n * token, so no route can attribute an action to an impersonator by passing one.\n */\nexport interface RemoteAuditWireEvent extends RemoteAuditEvent {\n  impersonatorId?: string;\n}\n\n/** `details` keys only `record()` may write (see {@link RemoteAuditEvent.details}). */\nconst RESERVED_DETAIL_KEYS = ['_auth', '_context'] as const;\n\n/**\n * Stamp an event with the ambient audit context at the moment it is RECORDED.\n * Persisted on the event, so a spooled re-delivery carries the original\n * request's context rather than whatever is ambient when the drain runs.\n */\nfunction stampAuditContext(event: RemoteAuditEvent): RemoteAuditWireEvent {\n  const ctx = currentAuditContext();\n  const principal = ctx?.principal?.();\n  const auth = auditAuthBlock(principal);\n  const context = { ...ctx?.correlation, ...ctx?.job };\n  const anonymous = event.actorId === ANONYMOUS_ACTOR_ID;\n  const details: Record<string, unknown> = { ...event.details };\n  for (const key of RESERVED_DETAIL_KEYS) delete details[key];\n  if (auth) details._auth = auth;\n  if (Object.keys(context).length > 0) details._context = context;\n  return {\n    ...event,\n    requestId: event.requestId ?? ctx?.requestId,\n    traceId: event.traceId ?? ctx?.traceId,\n    ip: event.ip ?? (anonymous ? undefined : ctx?.ip),\n    userAgent: event.userAgent ?? (anonymous ? undefined : ctx?.userAgent),\n    ...(principal?.impersonatorId ? { impersonatorId: principal.impersonatorId } : {}),\n    ...(Object.keys(details).length > 0 ? { details } : { details: undefined }),\n  };\n}\n\n/**\n * Whether this event may name an `affectedOrgId` outside its own org. Derived\n * ONLY from the stamped `_auth` block (the verified inbound principal), which\n * `record()` always overwrites — a call site cannot grant it.\n */\nfunction crossOrgAuthorized(event: RemoteAuditWireEvent): boolean {\n  if (!event.affectedOrgId || event.affectedOrgId === event.orgId) return false;\n  const auth = event.details?._auth as { superAdmin?: boolean; systemOrg?: boolean } | undefined;\n  return auth?.superAdmin === true || auth?.systemOrg === true;\n}\n\n/**\n * Result of one delivery attempt. `rejected` is a PERMANENT refusal (a 4xx other\n * than 408/429): the platform will never accept this event, so retrying it only\n * wedges the spool behind it.\n */\ntype DeliveryResult = { kind: 'delivered' } | { kind: 'retry' } | { kind: 'rejected'; status: number };\n\n/** 4xx statuses that are transient, not a verdict on the event. */\nconst RETRYABLE_4XX = new Set([408, 429]);\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 ?? serviceEndpoint('platform').host,\n    port: config.port ?? serviceEndpoint('platform').port,\n    timeout: config.timeout ?? 3000,\n  };\n  // Its own breaker route class: audit ingest failing (5xx while platform's\n  // audit store is degraded) must not open the breaker that platform's JWKS and\n  // key-exchange calls ride on — that would turn an audit brownout into an auth\n  // outage in every service.\n  const client = createSafeClient(serviceConfig, { breakerClass: 'audit' });\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: RemoteAuditWireEvent, serviceName: string): Promise<DeliveryResult> {\n    try {\n      // Minting the token is INSIDE the try on purpose. It can throw — the\n      // signing key unreadable, not an EC P-256 key, or `SERVICE_NAME` not\n      // matching this client's name. Outside the `try`, `deliver` would reject\n      // instead of resolving `false`; `record` fires it with a bare `.then`, so\n      // the rejection would go unhandled and crash-loop the pod on its first\n      // audited write. Inside, a key problem is just an undeliverable event:\n      // spooled, or dropped and metered.\n      const authHeader = getServiceAuthHeader({\n        serviceName,\n        orgId: event.orgId,\n        role: 'member',\n        ...(crossOrgAuthorized(event) ? { auditCrossOrg: true } : {}),\n      });\n      const headers: Record<string, string> = {\n        'Authorization': authHeader,\n        'Idempotency-Key': event.idempotencyKey ?? randomUUID(),\n      };\n      const response = await client.post('/audit/events', event, { headers, ...AUDIT_REQUEST_OPTIONS });\n      const status = response?.statusCode;\n      if (status !== undefined && status >= 200 && status < 300) return { kind: 'delivered' };\n      if (status !== undefined && status >= 400 && status < 500 && !RETRYABLE_4XX.has(status)) {\n        return { kind: 'rejected', status };\n      }\n      logger.warn('Remote audit ingest non-ok', { action: event.action, statusCode: status });\n      return { kind: 'retry' };\n    } catch (err) {\n      logger.warn('Remote audit ingest threw', { action: event.action, error: errorMessage(err) });\n      return { kind: 'retry' };\n    }\n  }\n\n  /**\n   * A permanently refused event is DROPPED — loudly. Spooling it would put it at\n   * the head of the queue forever (the drain stops at the first failure), so one\n   * malformed event would silently stall every later event this service emits.\n   * `AuditEventsRejected` pages on the counter.\n   */\n  function reportRejected(event: RemoteAuditWireEvent, serviceName: string, status: number): void {\n    emitCounter('audit_events_rejected_total', { service: serviceName, status: String(status) });\n    logger.error('Remote audit event REJECTED by ingest (dropped, not retried)', {\n      action: event.action,\n      statusCode: status,\n      orgId: event.orgId,\n      affectedOrgId: event.affectedOrgId,\n      targetType: event.targetType,\n      targetId: event.targetId,\n      requestId: event.requestId,\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        // `settled` = delivered OR permanently rejected: either way it leaves the\n        // spool. Only a retryable failure stops the sweep and goes back.\n        const settled: AuditSpoolEntry[] = [];\n        const failed: AuditSpoolEntry[] = [];\n        let platformDown = false;\n        for (const entry of batch) {\n          if (platformDown) { failed.push(entry); continue; }\n          const result = await deliver(entry.event, entry.serviceName);\n          if (result.kind === 'delivered') {\n            settled.push(entry);\n            emitCounter('audit_spool_redelivered_total', { service: entry.serviceName });\n          } else if (result.kind === 'rejected') {\n            settled.push(entry);\n            reportRejected(entry.event, entry.serviceName, result.status);\n          } else {\n            platformDown = true;\n            failed.push(entry);\n          }\n        }\n        // Acknowledge the settled entries so they clear 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 (settled.length > 0) await spool.ack(settled);\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: errorMessage(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    // Every tick: heartbeat (so peers never reclaim a batch this pod is still\n    // delivering — even mid-drain), reclaim batches of pods that died, drain.\n    drainTimer = setInterval(() => {\n      void spool.heartbeat().then(() => spool.recover()).then(() => drain());\n    }, 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 the ambient request/job context and when the action actually\n      // occurred (all survive spool delay), and pin a stable idempotency key so a\n      // live attempt and its spooled retry dedup.\n      const stamped: RemoteAuditWireEvent = {\n        ...stampAuditContext(event),\n        occurredAt: event.occurredAt ?? new Date().toISOString(),\n        idempotencyKey: event.idempotencyKey ?? randomUUID(),\n      };\n      void deliver(stamped, serviceName).then((result) => {\n        if (result.kind === 'delivered') {\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 (result.kind === 'rejected') {\n          reportRejected(stamped, serviceName, result.status);\n        } else if (spool) {\n          void spool.enqueue({ event: stamped, serviceName });\n        } else {\n          emitCounter('audit_dropped_total', { service: serviceName });\n        }\n      }).catch((err) => {\n        // Belt and braces. `deliver` never rejects, but anything that throws\n        // in the continuation would otherwise become an unhandled rejection —\n        // and in this process that is a crash, not a log line. An audit event\n        // must never take the service down.\n        emitCounter('audit_dropped_total', { service: serviceName });\n        logger.error('Remote audit record failed unexpectedly', { action: stamped.action, error: errorMessage(err) });\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  // Request context (ip / user agent / request id / credential / impersonator)\n  // is stamped by `record()` from the ambient audit context — the denial fires\n  // inside the request's scope. An unauthenticated denial has no org: it is\n  // recorded on the system org's chain rather than refused for lacking one.\n  setAuthzDenialAuditor((info: AuthzDenialInfo) => getClient().record({\n    action: 'authz.denied',\n    actorId: info.actorId ?? 'anonymous',\n    actorEmail: info.actorEmail,\n    orgId: info.orgId ?? SYSTEM_ORG_ID,\n    outcome: 'failure',\n    details: { method: info.method, path: info.path, required: info.required },\n  }, serviceName));\n}\n\n/**\n * The process-wide remote-audit binding: which service this process is, and the\n * (lazily built) client its events go through. Bound ONCE at boot by\n * `wireServiceSecurity(serviceName)` — every stateless service calls it — so the\n * service identity is never repeated at a call site and can never drift.\n */\ninterface AuditBinding {\n  serviceName: string;\n  client: RemoteAuditClient | null;\n}\n\nlet auditBinding: AuditBinding | null = null;\n\n/**\n * Bind this process's service identity for {@link recordAudit}. Called by\n * `wireServiceSecurity`; tests go through `bindTestAuditService`\n * (`@pipeline-builder/api-core/testing`), which passes a spy `client`.\n *\n * Without `client`, the real one is built lazily on first emission: a\n * RemoteAuditClient wired to the durable env-Redis spool (null → no spool).\n * Lazy on purpose — building it at boot would force the spool's Redis connection\n * wherever the service module is merely imported. Rebinding closes the previous\n * client's spool-drain timer.\n */\nexport function bindAuditService(serviceName: string, client?: RemoteAuditClient): void {\n  auditBinding?.client?.close();\n  auditBinding = { serviceName, client: client ?? null };\n}\n\n/** Drop the binding (tests only — returns the process to the unbound state). */\nexport function unbindAuditService(): void {\n  auditBinding?.client?.close();\n  auditBinding = null;\n}\n\nfunction boundAudit(): AuditBinding & { client: RemoteAuditClient } {\n  if (!auditBinding) {\n    throw new Error('audit not initialised: call wireServiceSecurity(serviceName) at boot before recordAudit()');\n  }\n  auditBinding.client ??= createRemoteAuditClient({\n    spool: createEnvRedisAuditSpool({ key: auditSpoolKey(auditBinding.serviceName) }) ?? undefined,\n  });\n  return auditBinding as AuditBinding & { client: RemoteAuditClient };\n}\n\n/**\n * The bound service's RemoteAuditClient. Throws \"audit not initialised\" before\n * `wireServiceSecurity` has run. Internal: callers emit through\n * {@link recordAudit}; `wireServiceSecurity` hands this getter to the\n * `authz.denied` sink.\n */\nexport function getBoundAuditClient(): RemoteAuditClient {\n  return boundAudit().client;\n}\n\n/**\n * Record an event in the durable, hash-chained central audit trail (platform's\n * `POST /audit/events` ingest), attributed to the service bound at boot.\n *\n * FIRE-AND-FORGET: delivery never blocks or throws — emit only AFTER the\n * mutation succeeds, and keep `details` free of secrets/tokens, PII and AWS\n * account ids. The ONE thing that throws is calling it before\n * `wireServiceSecurity(serviceName)` has bound the service: that is a wiring\n * bug, and failing loudly beats silently attributing the event to nobody.\n *\n * (The winston/Loki log line is a different sink: `logAuditEvent`.)\n */\nexport function recordAudit(event: RemoteAuditEvent): void {\n  const { client, serviceName } = boundAudit();\n  client.record(event, serviceName);\n}\n"]}

package/lib/services/version-vuln-policy.d.ts

@@ -0,0 +1,174 @@
+/**
+ * THE vulnerability assessment of one resolved plugin version, for one org (and,
+ * optionally, one pipeline's risk acceptance). One function, three callers:
+ * `/plugins/lookup` (what synth pins), `/plugins/runtime-check` (what a running
+ * pipeline is about to execute) and the pipeline service's save-time contract
+ * check. Three copies of these rules drifted once already.
+ *
+ * Vulnerability state NEVER refuses a pipeline — not its save, its synth, its
+ * deploy or its run. What it produces is SEVERITY-GRADED warnings (and, from the
+ * callers, notifications to the pipeline's owners). The grades:
+ *
+ *   critical — a finding on the CISA Known Exploited Vulnerabilities list
+ *   error    — the version is FLAGGED (gated Criticals over the platform floor),
+ *              it has fixable Critical findings, or an org compliance rule on the
+ *              vulnerability attributes is in BLOCK mode and fails
+ *   warning  — fixable High findings over the org's `warnFixableHigh`, a version
+ *              never scanned, a scan older than `PLUGIN_SCAN_STALE_HOURS`, or a
+ *              compliance rule in WARN mode
+ *   info     — what a reader may want to know but need not act on
+ *
+ * A PIPELINE's active risk acceptance (`plugin_vuln_exposure`, triaged `accepted`
+ * with a reason and an expiry) downgrades the warnings about the findings it
+ * ACCEPTED to `info` ("accepted until …") — never one about a finding that
+ * appeared since, never a KEV one unless the acceptance said `kev: true`, and
+ * never the scan-freshness or compliance warnings (neither is about a finding).
+ */
+import { createComplianceClient } from './compliance-client.js';
+import { type PluginScanFinding, type PluginScanFlag } from '../types/plugin-scan.js';
+import { type PluginImageRow } from '../utils/plugin-compliance.js';
+/** How loud a warning is, quietest first. */
+export declare const VULN_SEVERITIES: readonly ['info', 'warning', 'error', 'critical'];
+export type VulnSeverity = typeof VULN_SEVERITIES[number];
+/** The louder of two severities. */
+export declare function maxSeverity(a: VulnSeverity, b: VulnSeverity): VulnSeverity;
+/** Whether `s` is at least `floor`. */
+export declare function severityAtLeast(s: VulnSeverity, floor: VulnSeverity): boolean;
+/** `PLUGIN_SCAN_STALE_HOURS` (default 72): a scan older than this is stale. */
+export declare function scanStaleHours(): number;
+/** The scan-related fields of a resolved record (an org row or a listed record). */
+export interface ScannedRecord extends PluginImageRow {
+    name: string;
+    version: string;
+    scannedAt?: Date | string | null;
+    scanSummary?: unknown;
+    scanFlaggedAt?: Date | string | null;
+    scanFlag?: unknown;
+    vulnHighFixable?: unknown;
+}
+/**
+ * When the version was last scanned: the later of the build-time `scannedAt` and
+ * the nightly rescan's `scan_summary.scannedAt`. Null = never.
+ */
+export declare function lastScannedAt(record: Pick<ScannedRecord, 'scannedAt' | 'scanSummary'>): Date | null;
+/** Freshness of a version's scan: `none` (no image to scan), `unscanned`, `stale` or `fresh`. */
+export declare function scanFreshness(record: ScannedRecord, now?: Date): {
+    state: 'none' | 'unscanned' | 'stale' | 'fresh';
+    scannedAt: Date | null;
+};
+/** One severity-graded vulnerability warning. */
+export type VulnWarning = {
+    code: 'VULN_KEV' | 'VULN_FLAGGED' | 'VULN_CRITICAL_FIXABLE' | 'VULN_HIGH_FIXABLE';
+    severity: VulnSeverity;
+    message: string;
+    findings: PluginScanFinding[];
+    suggestedVersion?: string;
+    /** `VULN_FLAGGED` carries the flag's counts (the shape the rescan-flag warning always had). */
+    plugin?: string;
+    version?: string;
+    /** The flag's gated count (findings at or above its `failOn`). */
+    gated?: number;
+    high?: number;
+} | {
+    code: 'VULN_ACCEPTED';
+    severity: 'info';
+    message: string;
+    findings: string[];
+    acceptedUntil: string | null;
+    kev: boolean;
+    covers: string;
+} | {
+    code: 'UNSCANNED';
+    severity: VulnSeverity;
+    message: string;
+} | {
+    code: 'SCAN_STALE';
+    severity: VulnSeverity;
+    message: string;
+    scannedAt: string;
+    staleAfterHours: number;
+} | {
+    code: 'COMPLIANCE_VULN_RULE';
+    severity: VulnSeverity;
+    message: string;
+    ruleId: string;
+    ruleName: string;
+    field: string;
+    mode: 'block' | 'warn';
+} | {
+    code: 'COMPLIANCE_UNAVAILABLE';
+    severity: VulnSeverity;
+    message: string;
+};
+/** `UNSCANNED` / `SCAN_STALE` for a resolved version (empty for a fresh scan or an image-less plugin). */
+export declare function scanWarnings(record: ScannedRecord, now?: Date): VulnWarning[];
+/** The vulnerability fields of an org's consumption policy (pipeline-data's `ConsumptionPolicy` satisfies it). */
+export interface VulnConsumptionPolicy {
+    /** Fixable High findings above this many raise a `warning`; null = never (they stay `info`). */
+    warnFixableHigh: number | null;
+}
+/**
+ * A pipeline's ACTIVE risk acceptance of one version / image: the finding keys
+ * ({@link scanFindingKey}) it accepted, whether it accepted KEV findings, and
+ * until when. Built by pipeline-data from `plugin_vuln_exposure`.
+ */
+export interface VulnAcceptance {
+    findingKeys: readonly string[];
+    kev: boolean;
+    acceptedUntil: Date | string | null;
+}
+/** What a version's stored scan says, normalized from `scan_summary` (for its image) and `scan_flag`. */
+export interface VersionScanFacts {
+    flagged: boolean;
+    flag: PluginScanFlag | null;
+    /** Fixable Critical / High findings (null = not known). */
+    criticalFixable: number | null;
+    highFixable: number | null;
+    /** Totals including unfixable findings (null = not known). */
+    critical: number | null;
+    high: number | null;
+    /** KEV-listed Critical + High findings. */
+    kev: number;
+    /** Every Critical/High finding the scan itemized (the summary's list, else the flag's). */
+    findings: PluginScanFinding[];
+    /** The summary cut its findings list — a subset check over it cannot be trusted. */
+    truncated: boolean;
+    scannedAt: Date | null;
+}
+/** The normalized scan facts of a resolved record. A summary describing another image is ignored. */
+export declare function versionScanFacts(record: ScannedRecord): VersionScanFacts;
+/** Input to {@link assessVersionVulns}. */
+export interface VersionVulnInput {
+    orgId: string;
+    record: ScannedRecord;
+    policy: VulnConsumptionPolicy;
+    /** The pipeline's active acceptance of this version / image, when the caller has a pipeline. */
+    acceptance?: VulnAcceptance | null;
+    /** The newest unflagged version the owner can move to, named on the finding warnings. */
+    suggestedVersion?: string | null;
+    /** Run the org's compliance rules (a network call). Default true. */
+    compliance?: boolean;
+    now?: Date;
+}
+/** The assessment: every warning, the loudest severity, and which accepted findings it downgraded. */
+export interface VersionVulnAssessment {
+    /** `null` when there is nothing to say. */
+    severity: VulnSeverity | null;
+    warnings: VulnWarning[];
+    /** Finding keys an acceptance downgraded (empty = no acceptance applied). */
+    acceptedFindings: string[];
+    facts: VersionScanFacts;
+}
+/** The loudest severity of `warnings`, or null for none. */
+export declare function severityOf(warnings: ReadonlyArray<{
+    severity?: VulnSeverity;
+}>): VulnSeverity | null;
+/**
+ * The assessment of one resolved version (see the module doc). Never throws and
+ * never refuses: a compliance outage adds an `info` `COMPLIANCE_UNAVAILABLE`.
+ */
+export declare function assessVersionVulns(input: VersionVulnInput): Promise<VersionVulnAssessment>;
+type ComplianceClient = Pick<ReturnType<typeof createComplianceClient>, 'dryRunPlugin'>;
+/** Test hook: replace the compliance client the assessment's compliance layer calls. */
+export declare function setVulnPolicyComplianceClientForTests(client: ComplianceClient | null): void;
+export {};