@pipeline-builder/api-core 3.4.89 → 3.4.91

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

@@ -1,9 +1,11 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import { randomUUID } from 'crypto';
+import { createEnvRedisAuditSpool } from './audit-spool.js';
 import { createSafeClient } from './http-client.js';
-import { getServiceAuthHeader } from '../middleware/auth.js';
+import { getServiceAuthHeader, setAuthzDenialAuditor } from '../middleware/auth.js';
 import { createLogger } from '../utils/logger.js';
+import { emitCounter } from '../utils/metric-emitter.js';
 const logger = createLogger('remote-audit');
 /**
  * Audit ingest is best-effort and MUST NOT block the caller, but a transient
@@ -18,6 +20,99 @@ const AUDIT_REQUEST_OPTIONS = {
     maxRateLimitRetries: 2,
     maxRetries: 2,
 };
+/**
+ * The exact set of audit actions a NON-PLATFORM (remote) service is permitted to
+ * emit through `POST /audit/events`. This is the SINGLE SOURCE — `RemoteAuditAction`
+ * is derived from it, so the type and the runtime allow-list can never drift.
+ *
+ * SECURITY: platform's ingest validates `action` against this subset (via
+ * {@link isRemoteAuditAction}), NOT the full platform `AuditAction` union — a
+ * `service:*` token must not be able to forge platform-authority events
+ * (`admin.superadmin.grant`, `org.ownership.transfer`, `user.login`, …). Keep
+ * this list free of any platform-only action.
+ */
+export const REMOTE_AUDIT_ACTIONS = [
+    'plugin.build.completed',
+    'plugin.build.failed',
+    'plugin.build.timeout',
+    // Plugin lifecycle mutations (api/plugin route handlers) — the destructive /
+    // publishing surface that builds already audit's counterpart: registry delete,
+    // source upload, and deploy-to-cluster. `targetId` is the plugin id.
+    'plugin.delete',
+    'plugin.upload',
+    'plugin.deploy',
+    // Plugin bulk mutations (api/plugin bulk-plugin route) + DLQ purge (drops all
+    // dead-lettered build jobs, cross-org, sysadmin). `details` carries counts.
+    'plugin.bulk.update',
+    'plugin.bulk.delete',
+    'plugin.dlq.purge',
+    // Pipeline mutations — emitted by api/pipeline's route handlers
+    // (create/update/delete + CodePipeline execution trigger/cancel) and
+    // posted to platform's `POST /audit/events` ingest.
+    'pipeline.create',
+    'pipeline.update',
+    'pipeline.delete',
+    'pipeline.execution.start',
+    'pipeline.execution.cancel',
+    // CodePipeline ARN-registry config (api/pipeline registry route) — registering /
+    // deregistering the external CodePipeline that backs a pipeline (deploy-affecting).
+    'pipeline.registry.register',
+    'pipeline.registry.deregister',
+    // Quota administration (api/quota) — a superadmin resetting an org's usage
+    // counter or editing its tier limits. `affectedOrgId` is the org changed;
+    // `details` carries the quotaType + old/new value.
+    'quota.reset',
+    'quota.limit.update',
+    // A superadmin deleting an org's entire quota document.
+    'quota.delete',
+    // Compliance administration (api/compliance) — the enforcement-posture surface.
+    // Approving/revoking an exemption, toggling/authoring/deleting a rule,
+    // authoring/deleting a policy, managing scan schedules, applying a template,
+    // or cancelling a running scan. `targetId` is the rule/policy/exemption/scan id.
+    'compliance.exemption.approve',
+    'compliance.exemption.revoke',
+    'compliance.rule.toggle',
+    'compliance.rule.create',
+    'compliance.rule.update',
+    'compliance.rule.delete',
+    'compliance.policy.create',
+    'compliance.policy.update',
+    'compliance.policy.delete',
+    'compliance.scan-schedule.create',
+    'compliance.scan-schedule.update',
+    'compliance.scan-schedule.delete',
+    'compliance.template.apply',
+    'compliance.scan.cancel',
+    // Image-registry destructive ops (api/image-registry) — garbage-collection
+    // sweeps and explicit image/tag deletes (previously only a log line).
+    'registry.gc',
+    'registry.image.delete',
+    // Messaging (api/message) — admin BROADCAST announcements + destructive
+    // deletes. 1:1 user messages are intentionally NOT audited (noise + they would
+    // pull private content into the trail). `details` carry metadata only
+    // (subject/type/scope), NEVER message body content.
+    'message.announcement.create',
+    'message.delete',
+    // Billing (api/billing) — subscription + entitlement mutations, mirrored to the
+    // central audit trail (these also write to the service-local billing_events
+    // collection). `details` carry plan/tier/addon ids only — never card/payment
+    // secrets or an AWS account id.
+    'billing.subscription.cancel',
+    'billing.subscription.delete',
+    'billing.tier.override',
+    'billing.addon.add',
+    'billing.addon.remove',
+    // Denied authorization attempt — emitted best-effort by the shared
+    // `requirePermission` / `requireSystemAdmin` gate when a state-changing
+    // (non-GET) request is rejected, so probing/escalation attempts are visible
+    // rather than invisible. `details` carries the required permission + path;
+    // `outcome` is 'failure'.
+    'authz.denied',
+];
+/** Whether `value` is an action a remote service may emit (the ingest allow-list). */
+export function isRemoteAuditAction(value) {
+    return REMOTE_AUDIT_ACTIONS.includes(value);
+}
 /**
  * Construct a remote-audit client targeted at the platform service.
  *
@@ -45,41 +140,153 @@ export function createRemoteAuditClient(config = {}) {
         timeout: config.timeout ?? 3000,
     };
     const client = createSafeClient(serviceConfig);
+    const spool = config.spool;
+    const drainBatchSize = config.drainBatchSize ?? 100;
+    /**
+     * Attempt ONE live delivery. Resolves `true` on a 2xx accept, `false` on any
+     * non-2xx / thrown error (the http-client has already applied the retry
+     * budget). A stable per-emission `Idempotency-Key` makes this non-idempotent
+     * POST retry-safe and lets the platform ingest dedup a re-delivered event
+     * instead of writing a duplicate audit row (and duplicate chain link).
+     * `Idempotency-Key` is derived from the event so a SPOOLED re-delivery reuses
+     * the same key as its original live attempt — the two collapse to one row.
+     */
+    async function deliver(event, serviceName) {
+        const authHeader = getServiceAuthHeader({ serviceName, orgId: event.orgId, role: 'member' });
+        const headers = {
+            'Authorization': authHeader,
+            'Idempotency-Key': event.idempotencyKey ?? randomUUID(),
+        };
+        try {
+            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 });
+            }
+            return ok;
+        }
+        catch (err) {
+            logger.warn('Remote audit ingest threw', { action: event.action, error: err instanceof Error ? err.message : String(err) });
+            return false;
+        }
+    }
+    // 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.
+    let draining = false;
+    async function drain() {
+        if (!spool || draining)
+            return;
+        draining = true;
+        try {
+            for (;;) {
+                const batch = await spool.take(drainBatchSize);
+                if (batch.length === 0)
+                    return;
+                const failed = [];
+                let platformDown = false;
+                for (const entry of batch) {
+                    if (platformDown) {
+                        failed.push(entry);
+                        continue;
+                    }
+                    const ok = await deliver(entry.event, entry.serviceName);
+                    if (ok) {
+                        emitCounter('audit_spool_redelivered_total', { service: entry.serviceName });
+                    }
+                    else {
+                        platformDown = true;
+                        failed.push(entry);
+                    }
+                }
+                if (failed.length > 0) {
+                    await spool.requeue(failed);
+                    return; // still down — try again on the next tick
+                }
+            }
+        }
+        catch (err) {
+            logger.warn('Audit spool drain failed', { error: err instanceof Error ? err.message : String(err) });
+        }
+        finally {
+            draining = false;
+        }
+    }
+    let drainTimer;
+    if (spool) {
+        drainTimer = setInterval(() => { void drain(); }, config.drainIntervalMs ?? 30_000);
+        // Don't let the drain timer keep the process alive on shutdown.
+        drainTimer.unref?.();
+    }
     return {
         record(event, serviceName) {
-            const authHeader = getServiceAuthHeader({ serviceName, orgId: event.orgId, role: 'member' });
-            // getServiceAuthHeader returns a full `Bearer <token>` value; the
-            // http-client forwards request headers as-is (it does NOT inject its own
-            // Authorization), so pass it straight through as the Authorization header.
-            // A stable per-emission Idempotency-Key makes this non-idempotent POST
-            // retry-safe in the http-client (so transient 5xx/timeout/429 are retried
-            // rather than dropped) and lets the platform ingest dedup a re-delivered
-            // event instead of writing a duplicate audit row. Generated once here so
-            // every retry of THIS emission reuses the same key.
-            const headers = {
-                'Authorization': authHeader,
-                'Idempotency-Key': randomUUID(),
+            // Stamp when the action actually occurred (survives spool delay) and pin a
+            // stable idempotency key so a live attempt and its spooled retry dedup.
+            const stamped = {
+                ...event,
+                occurredAt: event.occurredAt ?? new Date().toISOString(),
+                idempotencyKey: event.idempotencyKey ?? randomUUID(),
             };
-            // Path is /audit/events  the platform mounts the audit router under
-            // /audit, and the internal ingest endpoint lives at /events under that.
-            client.post('/audit/events', event, { headers, ...AUDIT_REQUEST_OPTIONS })
-                .then((response) => {
-                // Any 2xx is an accept (the ingest returns 200 today, but 201/202/204
-                // are equally "stored"); only a non-2xx / missing response warns.
-                const ok = response && response.statusCode >= 200 && response.statusCode < 300;
-                if (!ok) {
-                    logger.warn('Remote audit ingest non-ok', {
-                        action: event.action, statusCode: response?.statusCode,
-                    });
+            void deliver(stamped, serviceName).then((ok) => {
+                if (ok) {
+                    emitCounter('audit_emitted_total', { service: serviceName, outcome: stamped.outcome ?? 'success' });
+                    if (spool)
+                        void drain(); // platform is reachable — flush any backlog
+                }
+                else if (spool) {
+                    void spool.enqueue({ event: stamped, serviceName });
+                }
+                else {
+                    emitCounter('audit_dropped_total', { service: serviceName });
                 }
-            })
-                .catch((err) => {
-                logger.warn('Remote audit ingest threw', {
-                    action: event.action,
-                    error: err instanceof Error ? err.message : String(err),
-                });
             });
         },
+        close() {
+            if (drainTimer) {
+                clearInterval(drainTimer);
+                drainTimer = undefined;
+            }
+        },
+    };
+}
+/**
+ * Register the standard `authz.denied` sink used by every remote-audit service
+ * (pipeline, plugin, compliance, quota, message, billing, reporting, …).
+ *
+ * The shared `requireAuth` gate forwards each DENIED state-changing request to
+ * the auditor set via {@link setAuthzDenialAuditor}; this wires that hook to the
+ * service's {@link RemoteAuditClient}, forwarding a `failure`-outcome
+ * `authz.denied` event so probing / privilege-escalation attempts leave a trail.
+ * Emission is fire-and-forget (the client never throws). `getClient` is a getter
+ * so the client stays lazily constructed (services memoize it on first use).
+ *
+ * Platform is intentionally NOT a caller — it is the audit authority and writes
+ * `authz.denied` straight to its local store (with `affectedOrgId`), not through
+ * a RemoteAuditClient.
+ */
+export function wireAuthzDenialAuditor(serviceName, getClient) {
+    setAuthzDenialAuditor((info) => getClient().record({
+        action: 'authz.denied',
+        actorId: info.actorId ?? 'anonymous',
+        actorEmail: info.actorEmail,
+        orgId: info.orgId,
+        outcome: 'failure',
+        details: { method: info.method, path: info.path, required: info.required },
+    }, serviceName));
+}
+/**
+ * Build a service's audit client: a RemoteAuditClient wired to the durable Redis
+ * spool (from ambient env; null → no spool) with `serviceName` bound. Construct
+ * ONCE per process — memoize behind a lazy `getAuditClient()` in the service's
+ * `services/audit.ts`. Pass `config.spool` to override the env-derived spool
+ * (e.g. reuse a service's existing ioredis connection).
+ */
+export function createServiceAuditClient(serviceName, config = {}) {
+    const spool = config.spool ?? createEnvRedisAuditSpool() ?? undefined;
+    const client = createRemoteAuditClient({ ...config, spool });
+    return {
+        emit: (event) => client.record(event, serviceName),
+        client,
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remote-audit-client.js","sourceRoot":"","sources":["../../src/services/remote-audit-client.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,gBAAgB,EAAuB,MAAM,kBAAkB,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAE7D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,MAAM,GAAG,YAAY,CAAC,cAAc,CAAC,CAAC;AAE5C;;;;;;;;GAQG;AACH,MAAM,qBAAqB,GAA+D;IACxF,mBAAmB,EAAE,CAAC;IACtB,UAAU,EAAE,CAAC;CACd,CAAC;AA4FF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,uBAAuB,CAAC,SAAkC,EAAE;IAC1E,MAAM,aAAa,GAAkB;QACnC,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,qBAAqB,IAAI,UAAU;QACpE,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,qBAAqB,IAAI,MAAM,EAAE,EAAE,CAAC;QAC9E,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,IAAI;KAChC,CAAC;IACF,MAAM,MAAM,GAAG,gBAAgB,CAAC,aAAa,CAAC,CAAC;IAE/C,OAAO;QACL,MAAM,CAAC,KAAK,EAAE,WAAW;YACvB,MAAM,UAAU,GAAG,oBAAoB,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;YAC7F,kEAAkE;YAClE,yEAAyE;YACzE,2EAA2E;YAC3E,uEAAuE;YACvE,0EAA0E;YAC1E,yEAAyE;YACzE,yEAAyE;YACzE,oDAAoD;YACpD,MAAM,OAAO,GAA2B;gBACtC,eAAe,EAAE,UAAU;gBAC3B,iBAAiB,EAAE,UAAU,EAAE;aAChC,CAAC;YACF,oEAAoE;YACpE,wEAAwE;YACxE,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,GAAG,qBAAqB,EAAE,CAAC;iBACvE,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE;gBACjB,sEAAsE;gBACtE,kEAAkE;gBAClE,MAAM,EAAE,GAAG,QAAQ,IAAI,QAAQ,CAAC,UAAU,IAAI,GAAG,IAAI,QAAQ,CAAC,UAAU,GAAG,GAAG,CAAC;gBAC/E,IAAI,CAAC,EAAE,EAAE,CAAC;oBACR,MAAM,CAAC,IAAI,CAAC,4BAA4B,EAAE;wBACxC,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU;qBACvD,CAAC,CAAC;gBACL,CAAC;YACH,CAAC,CAAC;iBACD,KAAK,CAAC,CAAC,GAAY,EAAE,EAAE;gBACtB,MAAM,CAAC,IAAI,CAAC,2BAA2B,EAAE;oBACvC,MAAM,EAAE,KAAK,CAAC,MAAM;oBACpB,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAA,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;iBACvD,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACP,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { randomUUID } from 'crypto';\nimport { createSafeClient, type RequestOptions } from './http-client.js';\nimport { getServiceAuthHeader } from '../middleware/auth.js';\nimport type { ServiceConfig } from '../types/common.js';\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('remote-audit');\n\n/**\n * Audit ingest is best-effort and MUST NOT block the caller, but a transient\n * failure (429 / 5xx / connection reset / timeout) should not silently drop the\n * row on the first attempt. Each emission carries a stable per-event\n * `Idempotency-Key` (see `record`), so the http-client treats the POST as\n * retry-safe and the platform can dedup a retried delivery instead of writing a\n * duplicate row. Budget is kept small so a hard-down platform can't back the\n * worker up for long: base delay ×(2 retries) + a couple of 429 backoffs.\n */\nconst AUDIT_REQUEST_OPTIONS: Pick<RequestOptions, 'maxRateLimitRetries' | 'maxRetries'> = {\n  maxRateLimitRetries: 2,\n  maxRetries: 2,\n};\n\n/**\n * Subset of platform's AuditAction enum that non-platform services emit.\n * Kept in sync manually with platform/src/models/audit-event.ts; mismatched\n * actions are rejected by the platform ingest endpoint (400) so a drift is\n * visible in logs rather than silently dropped.\n */\nexport type RemoteAuditAction =\n  | 'plugin.build.completed'\n  | 'plugin.build.failed'\n  | 'plugin.build.timeout'\n  // Plugin lifecycle mutations (api/plugin route handlers) — the destructive /\n  // publishing surface that builds already audit's counterpart: registry delete,\n  // source upload, and deploy-to-cluster. `targetId` is the plugin id.\n  | 'plugin.delete'\n  | 'plugin.upload'\n  | 'plugin.deploy'\n  // Pipeline mutations — emitted by api/pipeline's route handlers\n  // (create/update/delete + CodePipeline execution trigger/cancel) and\n  // posted to platform's `POST /audit/events` ingest.\n  | 'pipeline.create'\n  | 'pipeline.update'\n  | 'pipeline.delete'\n  | 'pipeline.execution.start'\n  | 'pipeline.execution.cancel'\n  // Quota administration (api/quota) — a superadmin resetting an org's usage\n  // counter or editing its tier limits. `affectedOrgId` is the org changed;\n  // `details` carries the quotaType + old/new value.\n  | 'quota.reset'\n  | 'quota.limit.update'\n  // Compliance rule administration (api/compliance) — approving an exemption\n  // request, toggling a rule active/inactive, or cancelling a running scan.\n  // `targetId` is the rule/exemption/scan id.\n  | 'compliance.exemption.approve'\n  | 'compliance.rule.toggle'\n  | 'compliance.scan.cancel'\n  // Image-registry destructive ops (api/image-registry) — garbage-collection\n  // sweeps and explicit image/tag deletes (previously only a log line).\n  | 'registry.gc'\n  | 'registry.image.delete'\n  // Denied authorization attempt — emitted best-effort by the shared\n  // `requirePermission` / `requireSystemAdmin` gate when a state-changing\n  // (non-GET) request is rejected, so probing/escalation attempts are visible\n  // rather than invisible. `details` carries the required permission + path;\n  // `outcome` is 'failure'.\n  | 'authz.denied';\n\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  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.\n   */\n  record(event: RemoteAuditEvent, serviceName: string): 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\n/**\n * Construct a remote-audit client targeted at the platform service.\n *\n * Used by api/plugin's build worker to push `plugin.build.*` events into\n * the platform's MongoDB `audit_events` collection. Other services\n * with worker-style emitters can use the same client.\n *\n * @example\n * ```typescript\n * const auditClient = createRemoteAuditClient();\n * auditClient.record({\n * action: 'plugin.build.completed',\n * actorId: 'user-123',\n * orgId: 'org-acme',\n * targetType: 'plugin',\n * targetId: 'plugin-abc',\n * details: { name: 'my-plugin', version: '1.0.0' },\n * }, 'plugin');\n * ```\n */\nexport function createRemoteAuditClient(config: RemoteAuditClientConfig = {}): RemoteAuditClient {\n  const serviceConfig: ServiceConfig = {\n    host: config.host ?? process.env.PLATFORM_SERVICE_HOST ?? 'platform',\n    port: config.port ?? parseInt(process.env.PLATFORM_SERVICE_PORT ?? '3000', 10),\n    timeout: config.timeout ?? 3000,\n  };\n  const client = createSafeClient(serviceConfig);\n\n  return {\n    record(event, serviceName) {\n      const authHeader = getServiceAuthHeader({ serviceName, orgId: event.orgId, role: 'member' });\n      // getServiceAuthHeader returns a full `Bearer <token>` value; the\n      // http-client forwards request headers as-is (it does NOT inject its own\n      // Authorization), so pass it straight through as the Authorization header.\n      // A stable per-emission Idempotency-Key makes this non-idempotent POST\n      // retry-safe in the http-client (so transient 5xx/timeout/429 are retried\n      // rather than dropped) and lets the platform ingest dedup a re-delivered\n      // event instead of writing a duplicate audit row. Generated once here so\n      // every retry of THIS emission reuses the same key.\n      const headers: Record<string, string> = {\n        'Authorization': authHeader,\n        'Idempotency-Key': randomUUID(),\n      };\n      // Path is /audit/events  the platform mounts the audit router under\n      // /audit, and the internal ingest endpoint lives at /events under that.\n      client.post('/audit/events', event, { headers, ...AUDIT_REQUEST_OPTIONS })\n        .then((response) => {\n          // Any 2xx is an accept (the ingest returns 200 today, but 201/202/204\n          // are equally \"stored\"); only a non-2xx / missing response warns.\n          const ok = response && response.statusCode >= 200 && response.statusCode < 300;\n          if (!ok) {\n            logger.warn('Remote audit ingest non-ok', {\n              action: event.action, statusCode: response?.statusCode,\n            });\n          }\n        })\n        .catch((err: unknown) => {\n          logger.warn('Remote audit ingest threw', {\n            action: event.action,\n            error: err instanceof Error ? err.message: String(err),\n          });\n        });\n    },\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remote-audit-client.js","sourceRoot":"","sources":["../../src/services/remote-audit-client.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,wBAAwB,EAAyC,MAAM,kBAAkB,CAAC;AACnG,OAAO,EAAE,gBAAgB,EAAuB,MAAM,kBAAkB,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAwB,MAAM,uBAAuB,CAAC;AAE1G,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD,MAAM,MAAM,GAAG,YAAY,CAAC,cAAc,CAAC,CAAC;AAE5C;;;;;;;;GAQG;AACH,MAAM,qBAAqB,GAA+D;IACxF,mBAAmB,EAAE,CAAC;IACtB,UAAU,EAAE,CAAC;CACd,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,wBAAwB;IACxB,qBAAqB;IACrB,sBAAsB;IACtB,6EAA6E;IAC7E,+EAA+E;IAC/E,qEAAqE;IACrE,eAAe;IACf,eAAe;IACf,eAAe;IACf,8EAA8E;IAC9E,4EAA4E;IAC5E,oBAAoB;IACpB,oBAAoB;IACpB,kBAAkB;IAClB,gEAAgE;IAChE,qEAAqE;IACrE,oDAAoD;IACpD,iBAAiB;IACjB,iBAAiB;IACjB,iBAAiB;IACjB,0BAA0B;IAC1B,2BAA2B;IAC3B,iFAAiF;IACjF,oFAAoF;IACpF,4BAA4B;IAC5B,8BAA8B;IAC9B,2EAA2E;IAC3E,0EAA0E;IAC1E,mDAAmD;IACnD,aAAa;IACb,oBAAoB;IACpB,wDAAwD;IACxD,cAAc;IACd,gFAAgF;IAChF,uEAAuE;IACvE,6EAA6E;IAC7E,iFAAiF;IACjF,8BAA8B;IAC9B,6BAA6B;IAC7B,wBAAwB;IACxB,wBAAwB;IACxB,wBAAwB;IACxB,wBAAwB;IACxB,0BAA0B;IAC1B,0BAA0B;IAC1B,0BAA0B;IAC1B,iCAAiC;IACjC,iCAAiC;IACjC,iCAAiC;IACjC,2BAA2B;IAC3B,wBAAwB;IACxB,2EAA2E;IAC3E,sEAAsE;IACtE,aAAa;IACb,uBAAuB;IACvB,wEAAwE;IACxE,+EAA+E;IAC/E,sEAAsE;IACtE,oDAAoD;IACpD,6BAA6B;IAC7B,gBAAgB;IAChB,gFAAgF;IAChF,4EAA4E;IAC5E,6EAA6E;IAC7E,gCAAgC;IAChC,6BAA6B;IAC7B,6BAA6B;IAC7B,uBAAuB;IACvB,mBAAmB;IACnB,sBAAsB;IACtB,mEAAmE;IACnE,wEAAwE;IACxE,4EAA4E;IAC5E,2EAA2E;IAC3E,0BAA0B;IAC1B,cAAc;CACN,CAAC;AAIX,sFAAsF;AACtF,MAAM,UAAU,mBAAmB,CAAC,KAAa;IAC/C,OAAQ,oBAA0C,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AACrE,CAAC;AA0ED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,uBAAuB,CAAC,SAAkC,EAAE;IAC1E,MAAM,aAAa,GAAkB;QACnC,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,qBAAqB,IAAI,UAAU;QACpE,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,qBAAqB,IAAI,MAAM,EAAE,EAAE,CAAC;QAC9E,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,IAAI;KAChC,CAAC;IACF,MAAM,MAAM,GAAG,gBAAgB,CAAC,aAAa,CAAC,CAAC;IAC/C,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IAC3B,MAAM,cAAc,GAAG,MAAM,CAAC,cAAc,IAAI,GAAG,CAAC;IAEpD;;;;;;;;OAQG;IACH,KAAK,UAAU,OAAO,CAAC,KAAuB,EAAE,WAAmB;QACjE,MAAM,UAAU,GAAG,oBAAoB,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC7F,MAAM,OAAO,GAA2B;YACtC,eAAe,EAAE,UAAU;YAC3B,iBAAiB,EAAE,KAAK,CAAC,cAAc,IAAI,UAAU,EAAE;SACxD,CAAC;QACF,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,GAAG,qBAAqB,EAAE,CAAC,CAAC;YAClG,MAAM,EAAE,GAAG,CAAC,CAAC,QAAQ,IAAI,QAAQ,CAAC,UAAU,IAAI,GAAG,IAAI,QAAQ,CAAC,UAAU,GAAG,GAAG,CAAC;YACjF,IAAI,CAAC,EAAE,EAAE,CAAC;gBACR,MAAM,CAAC,IAAI,CAAC,4BAA4B,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC,CAAC;YACxG,CAAC;YACD,OAAO,EAAE,CAAC;QACZ,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,CAAC,IAAI,CAAC,2BAA2B,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAC5H,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED,+EAA+E;IAC/E,4EAA4E;IAC5E,yDAAyD;IACzD,IAAI,QAAQ,GAAG,KAAK,CAAC;IACrB,KAAK,UAAU,KAAK;QAClB,IAAI,CAAC,KAAK,IAAI,QAAQ;YAAE,OAAO;QAC/B,QAAQ,GAAG,IAAI,CAAC;QAChB,IAAI,CAAC;YACH,SAAS,CAAC;gBACR,MAAM,KAAK,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;gBAC/C,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;oBAAE,OAAO;gBAC/B,MAAM,MAAM,GAAsB,EAAE,CAAC;gBACrC,IAAI,YAAY,GAAG,KAAK,CAAC;gBACzB,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE,CAAC;oBAC1B,IAAI,YAAY,EAAE,CAAC;wBAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;wBAAC,SAAS;oBAAC,CAAC;oBACnD,MAAM,EAAE,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;oBACzD,IAAI,EAAE,EAAE,CAAC;wBACP,WAAW,CAAC,+BAA+B,EAAE,EAAE,OAAO,EAAE,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC;oBAC/E,CAAC;yBAAM,CAAC;wBACN,YAAY,GAAG,IAAI,CAAC;wBACpB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBACrB,CAAC;gBACH,CAAC;gBACD,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACtB,MAAM,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;oBAC5B,OAAO,CAAC,0CAA0C;gBACpD,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,CAAC,IAAI,CAAC,0BAA0B,EAAE,EAAE,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACvG,CAAC;gBAAS,CAAC;YACT,QAAQ,GAAG,KAAK,CAAC;QACnB,CAAC;IACH,CAAC;IAED,IAAI,UAAsD,CAAC;IAC3D,IAAI,KAAK,EAAE,CAAC;QACV,UAAU,GAAG,WAAW,CAAC,GAAG,EAAE,GAAG,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,eAAe,IAAI,MAAM,CAAC,CAAC;QACpF,gEAAgE;QAC/D,UAAgD,CAAC,KAAK,EAAE,EAAE,CAAC;IAC9D,CAAC;IAED,OAAO;QACL,MAAM,CAAC,KAAK,EAAE,WAAW;YACvB,2EAA2E;YAC3E,wEAAwE;YACxE,MAAM,OAAO,GAAqB;gBAChC,GAAG,KAAK;gBACR,UAAU,EAAE,KAAK,CAAC,UAAU,IAAI,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;gBACxD,cAAc,EAAE,KAAK,CAAC,cAAc,IAAI,UAAU,EAAE;aACrD,CAAC;YACF,KAAK,OAAO,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE;gBAC7C,IAAI,EAAE,EAAE,CAAC;oBACP,WAAW,CAAC,qBAAqB,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,SAAS,EAAE,CAAC,CAAC;oBACpG,IAAI,KAAK;wBAAE,KAAK,KAAK,EAAE,CAAC,CAAC,4CAA4C;gBACvE,CAAC;qBAAM,IAAI,KAAK,EAAE,CAAC;oBACjB,KAAK,KAAK,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,CAAC,CAAC;gBACtD,CAAC;qBAAM,CAAC;oBACN,WAAW,CAAC,qBAAqB,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE,CAAC,CAAC;gBAC/D,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC;QACD,KAAK;YACH,IAAI,UAAU,EAAE,CAAC;gBAAC,aAAa,CAAC,UAAU,CAAC,CAAC;gBAAC,UAAU,GAAG,SAAS,CAAC;YAAC,CAAC;QACxE,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,sBAAsB,CAAC,WAAmB,EAAE,SAAkC;IAC5F,qBAAqB,CAAC,CAAC,IAAqB,EAAE,EAAE,CAAC,SAAS,EAAE,CAAC,MAAM,CAAC;QAClE,MAAM,EAAE,cAAc;QACtB,OAAO,EAAE,IAAI,CAAC,OAAO,IAAI,WAAW;QACpC,UAAU,EAAE,IAAI,CAAC,UAAU;QAC3B,KAAK,EAAE,IAAI,CAAC,KAAK;QACjB,OAAO,EAAE,SAAS;QAClB,OAAO,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE;KAC3E,EAAE,WAAW,CAAC,CAAC,CAAC;AACnB,CAAC;AAeD;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB,CAAC,WAAmB,EAAE,SAAkC,EAAE;IAChG,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,wBAAwB,EAAE,IAAI,SAAS,CAAC;IACtE,MAAM,MAAM,GAAG,uBAAuB,CAAC,EAAE,GAAG,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;IAC7D,OAAO;QACL,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,WAAW,CAAC;QAClD,MAAM;KACP,CAAC;AACJ,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { randomUUID } from 'crypto';\nimport { createEnvRedisAuditSpool, type AuditSpool, type AuditSpoolEntry } from './audit-spool.js';\nimport { createSafeClient, type RequestOptions } from './http-client.js';\nimport { getServiceAuthHeader, setAuthzDenialAuditor, type AuthzDenialInfo } from '../middleware/auth.js';\nimport type { ServiceConfig } from '../types/common.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('remote-audit');\n\n/**\n * Audit ingest is best-effort and MUST NOT block the caller, but a transient\n * failure (429 / 5xx / connection reset / timeout) should not silently drop the\n * row on the first attempt. Each emission carries a stable per-event\n * `Idempotency-Key` (see `record`), so the http-client treats the POST as\n * retry-safe and the platform can dedup a retried delivery instead of writing a\n * duplicate row. Budget is kept small so a hard-down platform can't back the\n * worker up for long: base delay ×(2 retries) + a couple of 429 backoffs.\n */\nconst AUDIT_REQUEST_OPTIONS: Pick<RequestOptions, 'maxRateLimitRetries' | 'maxRetries'> = {\n  maxRateLimitRetries: 2,\n  maxRetries: 2,\n};\n\n/**\n * The exact set of audit actions a NON-PLATFORM (remote) service is permitted to\n * emit through `POST /audit/events`. This is the SINGLE SOURCE — `RemoteAuditAction`\n * is derived from it, so the type and the runtime allow-list can never drift.\n *\n * SECURITY: platform's ingest validates `action` against this subset (via\n * {@link isRemoteAuditAction}), NOT the full platform `AuditAction` union — a\n * `service:*` token must not be able to forge platform-authority events\n * (`admin.superadmin.grant`, `org.ownership.transfer`, `user.login`, …). Keep\n * this list free of any platform-only action.\n */\nexport const REMOTE_AUDIT_ACTIONS = [\n  'plugin.build.completed',\n  'plugin.build.failed',\n  'plugin.build.timeout',\n  // Plugin lifecycle mutations (api/plugin route handlers) — the destructive /\n  // publishing surface that builds already audit's counterpart: registry delete,\n  // source upload, and deploy-to-cluster. `targetId` is the plugin id.\n  'plugin.delete',\n  'plugin.upload',\n  'plugin.deploy',\n  // Plugin bulk mutations (api/plugin bulk-plugin route) + DLQ purge (drops all\n  // dead-lettered build jobs, cross-org, sysadmin). `details` carries counts.\n  'plugin.bulk.update',\n  'plugin.bulk.delete',\n  'plugin.dlq.purge',\n  // Pipeline mutations — emitted by api/pipeline's route handlers\n  // (create/update/delete + CodePipeline execution trigger/cancel) and\n  // posted to platform's `POST /audit/events` ingest.\n  'pipeline.create',\n  'pipeline.update',\n  'pipeline.delete',\n  'pipeline.execution.start',\n  'pipeline.execution.cancel',\n  // CodePipeline ARN-registry config (api/pipeline registry route) — registering /\n  // deregistering the external CodePipeline that backs a pipeline (deploy-affecting).\n  'pipeline.registry.register',\n  'pipeline.registry.deregister',\n  // Quota administration (api/quota) — a superadmin resetting an org's usage\n  // counter or editing its tier limits. `affectedOrgId` is the org changed;\n  // `details` carries the quotaType + old/new value.\n  'quota.reset',\n  'quota.limit.update',\n  // A superadmin deleting an org's entire quota document.\n  'quota.delete',\n  // Compliance administration (api/compliance) — the enforcement-posture surface.\n  // Approving/revoking an exemption, toggling/authoring/deleting a rule,\n  // authoring/deleting a policy, managing scan schedules, applying a template,\n  // or cancelling a running scan. `targetId` is the rule/policy/exemption/scan id.\n  'compliance.exemption.approve',\n  'compliance.exemption.revoke',\n  'compliance.rule.toggle',\n  'compliance.rule.create',\n  'compliance.rule.update',\n  'compliance.rule.delete',\n  'compliance.policy.create',\n  'compliance.policy.update',\n  'compliance.policy.delete',\n  'compliance.scan-schedule.create',\n  'compliance.scan-schedule.update',\n  'compliance.scan-schedule.delete',\n  'compliance.template.apply',\n  'compliance.scan.cancel',\n  // Image-registry destructive ops (api/image-registry) — garbage-collection\n  // sweeps and explicit image/tag deletes (previously only a log line).\n  'registry.gc',\n  'registry.image.delete',\n  // Messaging (api/message) — admin BROADCAST announcements + destructive\n  // deletes. 1:1 user messages are intentionally NOT audited (noise + they would\n  // pull private content into the trail). `details` carry metadata only\n  // (subject/type/scope), NEVER message body content.\n  'message.announcement.create',\n  'message.delete',\n  // Billing (api/billing) — subscription + entitlement mutations, mirrored to the\n  // central audit trail (these also write to the service-local billing_events\n  // collection). `details` carry plan/tier/addon ids only — never card/payment\n  // secrets or an AWS account id.\n  'billing.subscription.cancel',\n  'billing.subscription.delete',\n  'billing.tier.override',\n  'billing.addon.add',\n  'billing.addon.remove',\n  // Denied authorization attempt — emitted best-effort by the shared\n  // `requirePermission` / `requireSystemAdmin` gate when a state-changing\n  // (non-GET) request is rejected, so probing/escalation attempts are visible\n  // rather than invisible. `details` carries the required permission + path;\n  // `outcome` is 'failure'.\n  'authz.denied',\n] as const;\n\nexport type RemoteAuditAction = typeof REMOTE_AUDIT_ACTIONS[number];\n\n/** Whether `value` is an action a remote service may emit (the ingest allow-list). */\nexport function isRemoteAuditAction(value: string): value is RemoteAuditAction {\n  return (REMOTE_AUDIT_ACTIONS as readonly string[]).includes(value);\n}\n\nexport interface RemoteAuditEvent {\n  action: RemoteAuditAction;\n  actorId: string;\n  actorEmail?: string;\n  orgId?: string;\n  affectedOrgId?: string;\n  targetType?: string;\n  targetId?: string;\n  /**\n   * Did the audited action succeed or fail? Defaults to 'success' when omitted\n   * (the platform ingest applies the same default). Denied-authz events set\n   * 'failure' so a reviewer can filter attempts from completed actions.\n   */\n  outcome?: 'success' | 'failure';\n  /**\n   * When the audited action actually OCCURRED (ISO-8601), stamped at emission.\n   * The platform stores this for reviewers; it is NOT the chain-ordering field\n   * (the tamper-evident chain orders by ingest/`createdAt`). It matters for\n   * SPOOLED events: one buffered during a platform outage is re-delivered — and\n   * so chained — later, but `occurredAt` preserves when it really happened.\n   */\n  occurredAt?: string;\n  /**\n   * Stable per-emission dedup key (also sent as the `Idempotency-Key` header the\n   * platform ingest dedups on). Stamped by `record()` and carried on the spooled\n   * copy so a live attempt and its later re-delivery collapse to ONE stored row.\n   */\n  idempotencyKey?: string;\n  details?: Record<string, unknown>;\n}\n\n/**\n * Client for POSTing audit events to the platform's `/audit-events` ingest\n * endpoint. Mints a fresh service token per call (5 min TTL)  there's no\n * meaningful caching benefit when emissions are sparse.\n */\nexport interface RemoteAuditClient {\n  /**\n   * Fire-and-forget audit emission. Failures are logged at warn level but\n   * never thrown  the originating action (e.g. a plugin build) has its\n   * own success/failure path that shouldn't get polluted by a flaky audit\n   * downstream. When a {@link AuditSpool} is configured, an emission that\n   * exhausts its live retries is buffered and re-delivered later instead of\n   * being dropped.\n   */\n  record(event: RemoteAuditEvent, serviceName: string): void;\n  /** Stop the background spool-drain timer (if any). Safe to call repeatedly. */\n  close(): void;\n}\n\n/**\n * Configuration for the remote audit client.\n */\nexport interface RemoteAuditClientConfig {\n  /** Platform service host (default: env PLATFORM_SERVICE_HOST or 'platform') */\n  host?: string;\n  /** Platform service port (default: env PLATFORM_SERVICE_PORT or 3000) */\n  port?: number;\n  /** Request timeout ms (default 3000  audit shouldn't block the worker). */\n  timeout?: number;\n  /**\n   * Optional durable buffer. When set, an emission that exhausts its live retry\n   * budget (sustained platform outage) is spooled and re-delivered — on the next\n   * successful emission and on a periodic timer — instead of being lost.\n   */\n  spool?: AuditSpool;\n  /** Spool-drain interval ms (default 30_000). Only used when `spool` is set. */\n  drainIntervalMs?: number;\n  /** Max entries drained per sweep (default 100). */\n  drainBatchSize?: number;\n}\n\n/**\n * Construct a remote-audit client targeted at the platform service.\n *\n * Used by api/plugin's build worker to push `plugin.build.*` events into\n * the platform's MongoDB `audit_events` collection. Other services\n * with worker-style emitters can use the same client.\n *\n * @example\n * ```typescript\n * const auditClient = createRemoteAuditClient();\n * auditClient.record({\n * action: 'plugin.build.completed',\n * actorId: 'user-123',\n * orgId: 'org-acme',\n * targetType: 'plugin',\n * targetId: 'plugin-abc',\n * details: { name: 'my-plugin', version: '1.0.0' },\n * }, 'plugin');\n * ```\n */\nexport function createRemoteAuditClient(config: RemoteAuditClientConfig = {}): RemoteAuditClient {\n  const serviceConfig: ServiceConfig = {\n    host: config.host ?? process.env.PLATFORM_SERVICE_HOST ?? 'platform',\n    port: config.port ?? parseInt(process.env.PLATFORM_SERVICE_PORT ?? '3000', 10),\n    timeout: config.timeout ?? 3000,\n  };\n  const client = createSafeClient(serviceConfig);\n  const spool = config.spool;\n  const drainBatchSize = config.drainBatchSize ?? 100;\n\n  /**\n   * Attempt ONE live delivery. Resolves `true` on a 2xx accept, `false` on any\n   * non-2xx / thrown error (the http-client has already applied the retry\n   * budget). A stable per-emission `Idempotency-Key` makes this non-idempotent\n   * POST retry-safe and lets the platform ingest dedup a re-delivered event\n   * instead of writing a duplicate audit row (and duplicate chain link).\n   * `Idempotency-Key` is derived from the event so a SPOOLED re-delivery reuses\n   * the same key as its original live attempt — the two collapse to one row.\n   */\n  async function deliver(event: RemoteAuditEvent, serviceName: string): Promise<boolean> {\n    const authHeader = getServiceAuthHeader({ serviceName, orgId: event.orgId, role: 'member' });\n    const headers: Record<string, string> = {\n      'Authorization': authHeader,\n      'Idempotency-Key': event.idempotencyKey ?? randomUUID(),\n    };\n    try {\n      const response = await client.post('/audit/events', event, { headers, ...AUDIT_REQUEST_OPTIONS });\n      const ok = !!response && response.statusCode >= 200 && response.statusCode < 300;\n      if (!ok) {\n        logger.warn('Remote audit ingest non-ok', { action: event.action, statusCode: response?.statusCode });\n      }\n      return ok;\n    } catch (err) {\n      logger.warn('Remote audit ingest threw', { action: event.action, error: err instanceof Error ? err.message : String(err) });\n      return false;\n    }\n  }\n\n  // Serialize spool drains so a periodic tick and an on-success drain can't both\n  // pull the same batch. Stops early the moment a re-delivery fails (platform\n  // still down) so we don't hammer it or churn the buffer.\n  let draining = false;\n  async function drain(): Promise<void> {\n    if (!spool || draining) return;\n    draining = true;\n    try {\n      for (;;) {\n        const batch = await spool.take(drainBatchSize);\n        if (batch.length === 0) return;\n        const 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            emitCounter('audit_spool_redelivered_total', { service: entry.serviceName });\n          } else {\n            platformDown = true;\n            failed.push(entry);\n          }\n        }\n        if (failed.length > 0) {\n          await spool.requeue(failed);\n          return; // still down — try again on the next tick\n        }\n      }\n    } catch (err) {\n      logger.warn('Audit spool drain failed', { error: err instanceof Error ? err.message : String(err) });\n    } finally {\n      draining = false;\n    }\n  }\n\n  let drainTimer: ReturnType<typeof setInterval> | undefined;\n  if (spool) {\n    drainTimer = setInterval(() => { void drain(); }, config.drainIntervalMs ?? 30_000);\n    // Don't let the drain timer keep the process alive on shutdown.\n    (drainTimer as unknown as { unref?: () => void }).unref?.();\n  }\n\n  return {\n    record(event, serviceName) {\n      // Stamp when the action actually occurred (survives spool delay) and pin a\n      // stable idempotency key so a live attempt and its spooled retry dedup.\n      const stamped: RemoteAuditEvent = {\n        ...event,\n        occurredAt: event.occurredAt ?? new Date().toISOString(),\n        idempotencyKey: event.idempotencyKey ?? randomUUID(),\n      };\n      void deliver(stamped, serviceName).then((ok) => {\n        if (ok) {\n          emitCounter('audit_emitted_total', { service: serviceName, outcome: stamped.outcome ?? 'success' });\n          if (spool) void drain(); // platform is reachable — flush any backlog\n        } else if (spool) {\n          void spool.enqueue({ event: stamped, serviceName });\n        } else {\n          emitCounter('audit_dropped_total', { service: serviceName });\n        }\n      });\n    },\n    close() {\n      if (drainTimer) { clearInterval(drainTimer); drainTimer = undefined; }\n    },\n  };\n}\n\n/**\n * Register the standard `authz.denied` sink used by every remote-audit service\n * (pipeline, plugin, compliance, quota, message, billing, reporting, …).\n *\n * The shared `requireAuth` gate forwards each DENIED state-changing request to\n * the auditor set via {@link setAuthzDenialAuditor}; this wires that hook to the\n * service's {@link RemoteAuditClient}, forwarding a `failure`-outcome\n * `authz.denied` event so probing / privilege-escalation attempts leave a trail.\n * Emission is fire-and-forget (the client never throws). `getClient` is a getter\n * so the client stays lazily constructed (services memoize it on first use).\n *\n * Platform is intentionally NOT a caller — it is the audit authority and writes\n * `authz.denied` straight to its local store (with `affectedOrgId`), not through\n * a RemoteAuditClient.\n */\nexport function wireAuthzDenialAuditor(serviceName: string, getClient: () => RemoteAuditClient): void {\n  setAuthzDenialAuditor((info: AuthzDenialInfo) => getClient().record({\n    action: 'authz.denied',\n    actorId: info.actorId ?? 'anonymous',\n    actorEmail: info.actorEmail,\n    orgId: info.orgId,\n    outcome: 'failure',\n    details: { method: info.method, path: info.path, required: info.required },\n  }, serviceName));\n}\n\n/**\n * A service-scoped audit client: a durable-spool-backed {@link RemoteAuditClient}\n * with the service name pre-bound for emission. Replaces the per-service\n * boilerplate of `createRemoteAuditClient({ spool: createEnvRedisAuditSpool() ?? undefined })`\n * plus a hand-rolled `emit<Service>Audit` wrapper that repeats the service name.\n */\nexport interface ServiceAuditClient {\n  /** Emit an audit event with the service name bound. Fire-and-forget. */\n  emit(event: RemoteAuditEvent): void;\n  /** The underlying remote client — for `wireAuthzDenialAuditor` + `close()`. */\n  readonly client: RemoteAuditClient;\n}\n\n/**\n * Build a service's audit client: a RemoteAuditClient wired to the durable Redis\n * spool (from ambient env; null → no spool) with `serviceName` bound. Construct\n * ONCE per process — memoize behind a lazy `getAuditClient()` in the service's\n * `services/audit.ts`. Pass `config.spool` to override the env-derived spool\n * (e.g. reuse a service's existing ioredis connection).\n */\nexport function createServiceAuditClient(serviceName: string, config: RemoteAuditClientConfig = {}): ServiceAuditClient {\n  const spool = config.spool ?? createEnvRedisAuditSpool() ?? undefined;\n  const client = createRemoteAuditClient({ ...config, spool });\n  return {\n    emit: (event) => client.record(event, serviceName),\n    client,\n  };\n}\n"]}

package/lib/services/token-revocation.d.ts

@@ -20,6 +20,21 @@ export declare function tokenRevocationKey(userId: string): string;
  * outage degrades to the pre-existing behaviour rather than locking users out.
  */
 export declare function createRedisTokenRevocationStore(redis: RedisCacheClient): TokenRevocationStore;
+/**
+ * Build a {@link TokenRevocationStore} backed by a Redis client that is lazily
+ * constructed from the standard `REDIS_URL` or `REDIS_HOST`/`REDIS_PORT` env —
+ * for a stateless service that keeps NO Redis client of its own. The client is
+ * built on first `getCurrentVersion` call and memoized; `ioredis` is loaded via
+ * a guarded dynamic require so merely importing this never breaks a build/test
+ * where Redis isn't present.
+ *
+ * FULLY FAIL-OPEN: no env configured, an ioredis load failure, a connect error,
+ * or any read failure all resolve to `null` ("no known revocation"), so a
+ * service degrades to natural token expiry rather than locking users out. A
+ * service opts in with a single boot line:
+ *   `setTokenRevocationStore(createEnvRedisTokenRevocationStore());`
+ */
+export declare function createEnvRedisTokenRevocationStore(): TokenRevocationStore;
 /**
  * Publish a user's current `tokenVersion` so the stateless services see the
  * revocation immediately (platform side). Best-effort — never throws; a failure

package/lib/services/token-revocation.js

@@ -1,5 +1,6 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+import { createRequire } from 'module';
 import { createLogger } from '../utils/logger.js';
 const logger = createLogger('token-revocation');
 /**
@@ -46,6 +47,64 @@ export function createRedisTokenRevocationStore(redis) {
         },
     };
 }
+/**
+ * Build a {@link TokenRevocationStore} backed by a Redis client that is lazily
+ * constructed from the standard `REDIS_URL` or `REDIS_HOST`/`REDIS_PORT` env —
+ * for a stateless service that keeps NO Redis client of its own. The client is
+ * built on first `getCurrentVersion` call and memoized; `ioredis` is loaded via
+ * a guarded dynamic require so merely importing this never breaks a build/test
+ * where Redis isn't present.
+ *
+ * FULLY FAIL-OPEN: no env configured, an ioredis load failure, a connect error,
+ * or any read failure all resolve to `null` ("no known revocation"), so a
+ * service degrades to natural token expiry rather than locking users out. A
+ * service opts in with a single boot line:
+ *   `setTokenRevocationStore(createEnvRedisTokenRevocationStore());`
+ */
+export function createEnvRedisTokenRevocationStore() {
+    // undefined = not yet attempted; null = attempted and unavailable (stay off).
+    let cached;
+    function build() {
+        try {
+            const url = process.env.REDIS_URL;
+            const host = process.env.REDIS_HOST;
+            if (!url && !host)
+                return null; // Redis not configured — no-op reader.
+            // Dynamic require: ioredis is a runtime-only optional dep, never a static
+            // import, so this module loads cleanly wherever Redis isn't present.
+            const req = createRequire(import.meta.url);
+            const mod = req('ioredis');
+            const RedisCtor = (mod.Redis ?? mod.default ?? mod);
+            const opts = { maxRetriesPerRequest: 1, enableOfflineQueue: false };
+            const inst = url
+                ? new RedisCtor(url, opts)
+                : new RedisCtor({ host, port: parseInt(process.env.REDIS_PORT ?? '6379', 10), ...opts });
+            // Swallow connection errors (ioredis auto-reconnects) so an unhandled
+            // 'error' can't crash the process; the reader stays fail-open meanwhile.
+            inst
+                .on('error', (e) => logger.warn('Redis revocation-reader client error', {
+                error: e instanceof Error ? e.message : String(e),
+            }));
+            logger.info('Redis token-revocation reader initialized');
+            return inst;
+        }
+        catch (err) {
+            logger.warn('Redis unavailable for revocation reader; falling back to token expiry', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return null;
+        }
+    }
+    return {
+        async getCurrentVersion(userId) {
+            if (cached === undefined)
+                cached = build();
+            if (!cached)
+                return null;
+            return createRedisTokenRevocationStore(cached).getCurrentVersion(userId);
+        },
+    };
+}
 /**
  * Publish a user's current `tokenVersion` so the stateless services see the
  * revocation immediately (platform side). Best-effort — never throws; a failure
@@ -71,4 +130,4 @@ export async function publishTokenRevocation(redis, userId, tokenVersion, ttlSec
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token-revocation.js","sourceRoot":"","sources":["../../src/services/token-revocation.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createRequire } from 'module';\nimport type { RedisCacheClient } from './cache-service.js';\nimport type { TokenRevocationStore } from '../middleware/auth.js';\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('token-revocation');\n\n/**\n * Redis key namespace for the per-user current `tokenVersion`. The platform\n * PUBLISHES to this key on every privilege change; the stateless services READ\n * it in `requireAuth` (via {@link createRedisTokenRevocationStore}) to reject\n * tokens minted before that change. Publisher and readers MUST share this exact\n * prefix — hence both helpers live here, in one place.\n */\nexport const TOKEN_REVOCATION_KEY_PREFIX = 'authrev:tv:';\n\n/** The revocation key for a user id. */\nexport function tokenRevocationKey(userId: string): string {\n  return `${TOKEN_REVOCATION_KEY_PREFIX}${userId}`;\n}\n\n/**\n * Build a {@link TokenRevocationStore} backed by a Redis client, for a stateless\n * service to register via `setTokenRevocationStore`. Reads the current\n * `tokenVersion` the platform published for the user.\n *\n * Fail-open by contract: a miss, a parse failure, or a Redis error all yield\n * `null` (— `requireAuth` treats that as \"no known revocation\"), so a Redis\n * outage degrades to the pre-existing behaviour rather than locking users out.\n */\nexport function createRedisTokenRevocationStore(redis: RedisCacheClient): TokenRevocationStore {\n  return {\n    async getCurrentVersion(userId: string): Promise<number | null> {\n      try {\n        const raw = await redis.get(tokenRevocationKey(userId));\n        if (raw === null || raw === undefined || raw.trim() === '') return null;\n        // Strict integer parse: `Number` (unlike `parseInt`) rejects trailing\n        // garbage (\"5abc\" → NaN), so a corrupted entry fails open (null → \"not\n        // revoked\") rather than being read as a bogus version. The empty-string\n        // guard above matters because `Number('')` is 0, not NaN.\n        const n = Number(raw);\n        return Number.isInteger(n) ? n : null;\n      } catch (err) {\n        logger.debug('Token-revocation read failed (fail-open)', {\n          userId, error: err instanceof Error ? err.message : String(err),\n        });\n        return null;\n      }\n    },\n  };\n}\n\n/**\n * Build a {@link TokenRevocationStore} backed by a Redis client that is lazily\n * constructed from the standard `REDIS_URL` or `REDIS_HOST`/`REDIS_PORT` env —\n * for a stateless service that keeps NO Redis client of its own. The client is\n * built on first `getCurrentVersion` call and memoized; `ioredis` is loaded via\n * a guarded dynamic require so merely importing this never breaks a build/test\n * where Redis isn't present.\n *\n * FULLY FAIL-OPEN: no env configured, an ioredis load failure, a connect error,\n * or any read failure all resolve to `null` (\"no known revocation\"), so a\n * service degrades to natural token expiry rather than locking users out. A\n * service opts in with a single boot line:\n *   `setTokenRevocationStore(createEnvRedisTokenRevocationStore());`\n */\nexport function createEnvRedisTokenRevocationStore(): TokenRevocationStore {\n  // undefined = not yet attempted; null = attempted and unavailable (stay off).\n  let cached: RedisCacheClient | null | undefined;\n\n  function build(): RedisCacheClient | null {\n    try {\n      const url = process.env.REDIS_URL;\n      const host = process.env.REDIS_HOST;\n      if (!url && !host) return null; // Redis not configured — no-op reader.\n      // Dynamic require: ioredis is a runtime-only optional dep, never a static\n      // import, so this module loads cleanly wherever Redis isn't present.\n      const req = createRequire(import.meta.url);\n      const mod = req('ioredis') as {\n        Redis?: new (...args: unknown[]) => unknown;\n        default?: new (...args: unknown[]) => unknown;\n      };\n      const RedisCtor = (mod.Redis ?? mod.default ?? mod) as new (...args: unknown[]) => RedisCacheClient;\n      const opts = { maxRetriesPerRequest: 1, enableOfflineQueue: false };\n      const inst = url\n        ? new RedisCtor(url, opts)\n        : new RedisCtor({ host, port: parseInt(process.env.REDIS_PORT ?? '6379', 10), ...opts });\n      // Swallow connection errors (ioredis auto-reconnects) so an unhandled\n      // 'error' can't crash the process; the reader stays fail-open meanwhile.\n      (inst as unknown as { on: (evt: string, cb: (e: unknown) => void) => void })\n        .on('error', (e) => logger.warn('Redis revocation-reader client error', {\n          error: e instanceof Error ? e.message : String(e),\n        }));\n      logger.info('Redis token-revocation reader initialized');\n      return inst;\n    } catch (err) {\n      logger.warn('Redis unavailable for revocation reader; falling back to token expiry', {\n        error: err instanceof Error ? err.message : String(err),\n      });\n      return null;\n    }\n  }\n\n  return {\n    async getCurrentVersion(userId: string): Promise<number | null> {\n      if (cached === undefined) cached = build();\n      if (!cached) return null;\n      return createRedisTokenRevocationStore(cached).getCurrentVersion(userId);\n    },\n  };\n}\n\n/**\n * Publish a user's current `tokenVersion` so the stateless services see the\n * revocation immediately (platform side). Best-effort — never throws; a failure\n * just means the services fall back to natural token expiry for this change.\n *\n * The key is written with a TTL equal to the access-token lifetime: any token\n * that could still carry an older version has expired by the time the entry\n * lapses, so an expired entry can never cause a false \"revoked\" nor a missed one.\n *\n * @param redis - the platform's Redis client\n * @param userId - the user whose sessions changed\n * @param tokenVersion - the user's NEW (post-increment) tokenVersion\n * @param ttlSeconds - access-token lifetime in seconds\n */\nexport async function publishTokenRevocation(\n  redis: RedisCacheClient,\n  userId: string,\n  tokenVersion: number,\n  ttlSeconds: number,\n): Promise<void> {\n  try {\n    // ioredis-style variadic SET with expiry: SET key val EX ttl.\n    await redis.set(tokenRevocationKey(userId), String(tokenVersion), 'EX', Math.max(1, Math.floor(ttlSeconds)));\n  } catch (err) {\n    logger.warn('Token-revocation publish failed (services fall back to token expiry)', {\n      userId, error: err instanceof Error ? err.message : String(err),\n    });\n  }\n}\n"]}

package/lib/types/common.d.ts

@@ -1,4 +1,13 @@
 import type { Permission } from './permissions.js';
+import type { QuotaTier } from './quota-tiers.js';
+/**
+ * Capability scope catalog for machine/automation tokens. A scoped token carries
+ * exactly one of these instead of role-based permissions; endpoints that accept a
+ * scoped identity check it via `hasScope`. Kept a closed union (mirroring
+ * {@link Permission}) so a typo on either the mint or the check side is a compile
+ * error. Add a value here when introducing a new scoped-token surface.
+ */
+export type TokenScope = 'reporting:ingest';
 /**
  * Quota type identifiers.
  *
@@ -165,8 +174,8 @@ export interface JwtPayload {
      * during the rollout; new users should be granted via `isSuperAdmin`.
      */
     isSuperAdmin?: boolean;
-    /** Organization's quota tier ('developer' | 'pro' | 'team' | 'enterprise') */
-    tier?: string;
+    /** Organization's quota tier. */
+    tier?: QuotaTier;
     /** Resolved feature flags for this user/org */
     features?: string[];
     /**
@@ -175,7 +184,7 @@ export interface JwtPayload {
      * that accept a scoped identity check this (see `hasScope`) instead of role;
      * a scoped token is minted with minimal role for least-privilege.
      */
-    scope?: string;
+    scope?: TokenScope;
     /** Active organization ID (from UserOrganization membership) */
     organizationId?: string;
     /** Active organization name */