@pipeline-builder/api-core 5.2.2 → 5.2.4

package/lib/services/ai-call-weight.js

@@ -0,0 +1,77 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { OPENAI_COMPATIBLE_PROVIDER_ID } from '../constants/ai-providers.js';
+import { createLogger } from '../utils/logger.js';
+const logger = createLogger('ai-call-weight');
+/** Largest weight one model may carry — one call can never reserve more than this many units. */
+export const MAX_AI_CALL_WEIGHT = 100;
+/**
+ * Built-in weights, under whatever `AI_MODEL_WEIGHTS` sets. The self-hosted
+ * OpenAI-compatible provider (the in-cluster `ask-model`) runs on hardware the
+ * operator already pays for, so a call on it spends NO `aiCalls` unit by default;
+ * set `{"openai-compatible": 1}` to meter it like any other model.
+ */
+const BUILT_IN_WEIGHTS = { [OPENAI_COMPATIBLE_PROVIDER_ID]: 0 };
+/**
+ * Parse `AI_MODEL_WEIGHTS` — a JSON object of `key → integer weight` — into
+ * lower-cased entries. A malformed value is IGNORED (logged), never fatal: the
+ * weights are an optional pricing lever and every call still meters at 1.
+ */
+export function parseAiModelWeights(raw) {
+    const out = { ...BUILT_IN_WEIGHTS };
+    if (!raw || raw.trim() === '')
+        return out;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        logger.warn('AI_MODEL_WEIGHTS is not valid JSON; every model weighs 1');
+        return out;
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        logger.warn('AI_MODEL_WEIGHTS must be a JSON object; every model weighs 1');
+        return out;
+    }
+    for (const [key, value] of Object.entries(parsed)) {
+        if (typeof value !== 'number' || !Number.isInteger(value) || value < 0 || value > MAX_AI_CALL_WEIGHT) {
+            logger.warn('AI_MODEL_WEIGHTS entry ignored (weight must be an integer 0..100)', { key });
+            continue;
+        }
+        out[key.trim().toLowerCase()] = value;
+    }
+    return out;
+}
+let cached;
+function currentWeights() {
+    const raw = process.env.AI_MODEL_WEIGHTS;
+    if (!cached || cached.raw !== raw)
+        cached = { raw, weights: parseAiModelWeights(raw) };
+    return cached.weights;
+}
+/**
+ * How many `aiCalls` units one call on `{ provider, modelId }` reserves.
+ *
+ * MODEL-CLASS WEIGHTING is OFF by default: with `AI_MODEL_WEIGHTS` unset every
+ * model weighs 1 — except the self-hosted provider, which weighs 0 (see
+ * {@link BUILT_IN_WEIGHTS}). Matching, first hit wins:
+ *  1. a key equal to the PROVIDER id (`"openai-compatible": 0`, `"bedrock": 2`);
+ *  2. the LONGEST key contained in the model id (`"opus": 3` matches
+ *     `claude-opus-4-1`; `"sonnet": 1`, `"haiku": 1`).
+ * No match → 1. A weight of 0 means the call reserves nothing (it is still
+ * recorded in the usage ledger with its tokens).
+ */
+export function aiCallWeight(selection) {
+    const weights = currentWeights();
+    const provider = selection.provider.toLowerCase();
+    if (provider in weights)
+        return weights[provider];
+    const model = selection.modelId.toLowerCase();
+    let best;
+    for (const [key, weight] of Object.entries(weights)) {
+        if (key.length > 0 && model.includes(key) && (!best || key.length > best.key.length))
+            best = { key, weight };
+    }
+    return best ? best.weight : 1;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/services/alert-delivery.d.ts

@@ -0,0 +1,99 @@
+export interface SlackAlertsConfig {
+    /**
+     * Whether ops-team Slack delivery is DECLARED on.
+     *
+     * Defaults FALSE, matching `ONCALL_ENABLED`: both destinations are opt-in, so
+     * a deployment states what it wants rather than inheriting a channel it may
+     * not have. Note what this flag does NOT do — it cannot remove the Slack
+     * receivers, because `alertmanager.yml` is asserted byte-identical across
+     * targets and Alertmanager has no templating. A deployment with the flag off
+     * and real URLs in its Secret still delivers to Slack.
+     */
+    enabled: boolean;
+    /**
+     * Whether Slack delivery CAN happen — i.e. the webhook URLs are non-empty.
+     *
+     * Derived at deploy time (`pb_check_alert_delivery` writes it) because the
+     * URLs live in Alertmanager's Secret and never enter this process: a Slack
+     * webhook URL is a bearer credential, read per notification via
+     * `api_url_file`. Platform therefore cannot inspect them and must be told.
+     *
+     * SEPARATE FROM `enabled` for the same reason the pager splits the two, and
+     * the distinction is what keeps `AlertDeliveryDisabled` honest. Keying that
+     * alert on the DECLARATION would page every deployment that left the flag at
+     * its default while Slack was quietly working — a false alarm on a healthy
+     * system, which is the fastest way to teach people to ignore an alert.
+     */
+    configured: boolean;
+}
+export declare function slackAlertsConfig(): SlackAlertsConfig;
+/** Both destinations, resolved together — what `reportAlertDeliveryPosture` reads. */
+export interface AlertDeliveryConfig {
+    slack: SlackAlertsConfig;
+    pager: {
+        enabled: boolean;
+        configured: boolean;
+    };
+}
+/** Whether ANY destination could actually deliver — reality, not declaration. */
+export declare function canDeliverAnywhere(cfg: AlertDeliveryConfig): boolean;
+export declare function alertDeliveryConfig(): AlertDeliveryConfig;
+/**
+ * Publish the delivery posture as gauges, and shout if it is incoherent.
+ *
+ * Called once at boot. Gauges rather than counters because these are STATES of
+ * the deployment — an operator wants "will anyone hear an alert right now", not
+ * how many times a process started and wondered.
+ *
+ * The value of having this at all: before it, answering "does this deployment
+ * page anyone?" meant reading `.env`, two Secrets and four copies of
+ * `alertmanager.yml`. A deployment can now alert on its own inability to alert.
+ */
+export declare function reportAlertDeliveryPosture(cfg?: AlertDeliveryConfig): void;
+/**
+ * The dead-man switch: a heartbeat whose ABSENCE is the alert.
+ *
+ * Every other alert in this system depends on something inside it still working.
+ * This one inverts that — an external service expects a POST on a schedule and
+ * raises an incident when one does not arrive, so a platform that is wedged,
+ * crashed, partitioned or never started is reported BY ITS SILENCE. Nothing
+ * inside a broken deployment has to notice its own brokenness.
+ *
+ * WHY IT IS BUILT HERE RATHER THAN BOUGHT, when the rest of on-call deliberately
+ * is not: PagerDuty's heartbeat monitoring is an Event Orchestration pattern and
+ * documented as AIOps-powered, so it may sit behind a tier and is not part of
+ * Events v2. More importantly a dead-man switch is a CLOCK, not a telecom
+ * problem — the thing that made the last mile worth buying (carrier retries,
+ * delivery receipts, a 3am failure budget) simply does not apply to sending one
+ * request on an interval. `ONCALL_DEADMAN_URL` therefore points wherever the
+ * operator likes: PagerDuty's orchestration endpoint, a purpose-built dead-man
+ * service, or an uptime monitor.
+ *
+ * TWO PROPERTIES WORTH STATING, because they are the reason this is safe:
+ *
+ *  - It is NOT leader-locked. A heartbeat is per-process on purpose: with three
+ *    replicas, the external service hears from whichever are alive, and silence
+ *    means ALL of them stopped. Leader-locking it would make the switch report
+ *    the leader's health rather than the deployment's — and would make a Redis
+ *    outage look identical to a total outage.
+ *  - It fails SILENTLY on its own errors, deliberately. A heartbeat that logged
+ *    an error every interval during a network blip would be its own noise
+ *    source, and the consequence of a missed beat is already handled: the
+ *    external service alerts. The only thing it must never do is report success
+ *    it did not achieve, which is why nothing here swallows a non-2xx.
+ */
+export interface DeadmanConfig {
+    url: string;
+    intervalMs: number;
+}
+export declare function deadmanConfig(): DeadmanConfig;
+/**
+ * Start beating. No-op when `ONCALL_DEADMAN_URL` is unset, which is the default:
+ * an unconfigured dead-man switch must not beat against nothing, and must not
+ * pretend it is covering the deployment.
+ *
+ * Returns true when a timer was started, so a caller can log the posture.
+ */
+export declare function startDeadmanHeartbeat(cfg?: DeadmanConfig): boolean;
+/** Stop beating — called from the unified shutdown path, not a signal handler. */
+export declare function stopDeadmanHeartbeat(): void;

package/lib/services/alert-delivery.js

@@ -0,0 +1,132 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Where a platform-wide alert is meant to GO, as declared configuration.
+ *
+ * Two destinations, with different jobs. The ops-team Slack channels are the
+ * baseline: everything critical or warning lands there and that is where the
+ * thread, the context and the handover live. The pager is additive and narrow —
+ * only `severity: critical` + `component: support`, because that is the one
+ * alert backing a contractual out-of-hours promise.
+ *
+ * WHAT THIS MODULE CAN AND CANNOT DO, because the limit is not obvious.
+ * `config/alertmanager/alertmanager.yml` is in the deploy contract's
+ * REQUIRED_IDENTICAL set and asserted byte-identical across targets, and
+ * Alertmanager has no templating. So NOTHING here removes a receiver or a route
+ * — the routes are always present. What these flags do is:
+ *
+ *  - declare INTENT, so "we do not use Slack" is a stated decision rather than
+ *    something inferred from two empty URLs that look like an oversight;
+ *  - gate the deploy-time check (`pb_check_alert_delivery`), which is what turns
+ *    a half-configured channel into a refused deploy instead of a 3am surprise;
+ *  - drive the posture gauges below, so a dashboard can answer "is anyone
+ *    actually going to hear this" without reading four YAML files.
+ *
+ * The URLS THEMSELVES ARE NOT HERE, and that is deliberate. A Slack webhook URL
+ * is a bearer credential: anyone holding it can post to the channel. Alertmanager
+ * reads them from a mounted Secret via `api_url_file`, per notification, so they
+ * never enter a ConfigMap and never enter this process. Platform knows WHETHER
+ * Slack delivery is declared on; it does not know, and does not need, where to.
+ * The pager's routing key is different — that one IS consumed by this process, so
+ * it lives in `pagerDutyConfig()`.
+ */
+import { pagerDutyConfig } from './pagerduty.js';
+import { envBool, envInt, envStr } from '../utils/env.js';
+import { createLogger } from '../utils/logger.js';
+import { emitCounter, emitGauge } from '../utils/metric-emitter.js';
+import { safeFetch } from '../utils/ssrf.js';
+const logger = createLogger('alert-delivery');
+export function slackAlertsConfig() {
+    return {
+        enabled: envBool('SLACK_ALERTS_ENABLED', false),
+        configured: envBool('SLACK_ALERTS_CONFIGURED', false),
+    };
+}
+/** Whether ANY destination could actually deliver — reality, not declaration. */
+export function canDeliverAnywhere(cfg) {
+    return cfg.slack.configured || (cfg.pager.enabled && cfg.pager.configured);
+}
+export function alertDeliveryConfig() {
+    const pd = pagerDutyConfig();
+    return {
+        slack: slackAlertsConfig(),
+        // `configured` separately from `enabled`: enabled-without-a-key is the
+        // half-configured state worth seeing, and it is invisible if the two are
+        // collapsed into one boolean.
+        pager: { enabled: pd.enabled, configured: pd.routingKey.length > 0 },
+    };
+}
+/**
+ * Publish the delivery posture as gauges, and shout if it is incoherent.
+ *
+ * Called once at boot. Gauges rather than counters because these are STATES of
+ * the deployment — an operator wants "will anyone hear an alert right now", not
+ * how many times a process started and wondered.
+ *
+ * The value of having this at all: before it, answering "does this deployment
+ * page anyone?" meant reading `.env`, two Secrets and four copies of
+ * `alertmanager.yml`. A deployment can now alert on its own inability to alert.
+ */
+export function reportAlertDeliveryPosture(cfg = alertDeliveryConfig()) {
+    emitGauge('alert_delivery_enabled', { channel: 'slack' }, cfg.slack.enabled ? 1 : 0);
+    emitGauge('alert_delivery_enabled', { channel: 'pager' }, cfg.pager.enabled ? 1 : 0);
+    emitGauge('alert_delivery_configured', { channel: 'slack' }, cfg.slack.configured ? 1 : 0);
+    emitGauge('alert_delivery_configured', { channel: 'pager' }, cfg.pager.configured ? 1 : 0);
+    // Enabled with no credential: somebody asked for paging and is not getting it.
+    // The deploy check refuses this combination, so reaching here means it was
+    // changed after provisioning — which is exactly when nobody is looking.
+    if (cfg.pager.enabled && !cfg.pager.configured) {
+        logger.error('ONCALL_ENABLED is true but no PAGERDUTY_ROUTING_KEY is set — support criticals will not page');
+    }
+    // Nothing CAN deliver. Keyed on reachability rather than on the two flags,
+    // because the flags are declarations: a deployment that left both at their
+    // (false) defaults while real Slack URLs sit in its Secret is delivering
+    // fine, and warning it would be a lie.
+    if (!canDeliverAnywhere(cfg)) {
+        logger.warn('No platform alert destination is enabled — alerts will reach Alertmanager and go no further', {
+            hint: 'SLACK_ALERTS_ENABLED / ONCALL_ENABLED',
+        });
+    }
+}
+export function deadmanConfig() {
+    return {
+        url: envStr('ONCALL_DEADMAN_URL', ''),
+        intervalMs: envInt('ONCALL_DEADMAN_INTERVAL_MS', 60_000, { min: 1000 }),
+    };
+}
+let deadmanTimer;
+/**
+ * Start beating. No-op when `ONCALL_DEADMAN_URL` is unset, which is the default:
+ * an unconfigured dead-man switch must not beat against nothing, and must not
+ * pretend it is covering the deployment.
+ *
+ * Returns true when a timer was started, so a caller can log the posture.
+ */
+export function startDeadmanHeartbeat(cfg = deadmanConfig()) {
+    if (deadmanTimer || !cfg.url)
+        return false;
+    const beat = async () => {
+        try {
+            const resp = await safeFetch(cfg.url, { method: 'POST', timeoutMs: 5000, body: '{}', headers: { 'Content-Type': 'application/json' } });
+            emitCounter('oncall_deadman_total', { outcome: resp.ok && !resp.redirected ? 'sent' : 'failed' });
+        }
+        catch {
+            // Counted, never logged per-beat — see the module note on noise.
+            emitCounter('oncall_deadman_total', { outcome: 'failed' });
+        }
+    };
+    // `unref` so a pending beat cannot hold the process open during shutdown: the
+    // switch exists to report that the process STOPPED, and delaying that is
+    // precisely backwards.
+    deadmanTimer = setInterval(() => void beat(), cfg.intervalMs);
+    deadmanTimer.unref();
+    void beat();
+    return true;
+}
+/** Stop beating — called from the unified shutdown path, not a signal handler. */
+export function stopDeadmanHeartbeat() {
+    if (deadmanTimer)
+        clearInterval(deadmanTimer);
+    deadmanTimer = undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alert-delivery.js","sourceRoot":"","sources":["../../src/services/alert-delivery.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Where a platform-wide alert is meant to GO, as declared configuration.\n *\n * Two destinations, with different jobs. The ops-team Slack channels are the\n * baseline: everything critical or warning lands there and that is where the\n * thread, the context and the handover live. The pager is additive and narrow —\n * only `severity: critical` + `component: support`, because that is the one\n * alert backing a contractual out-of-hours promise.\n *\n * WHAT THIS MODULE CAN AND CANNOT DO, because the limit is not obvious.\n * `config/alertmanager/alertmanager.yml` is in the deploy contract's\n * REQUIRED_IDENTICAL set and asserted byte-identical across targets, and\n * Alertmanager has no templating. So NOTHING here removes a receiver or a route\n * — the routes are always present. What these flags do is:\n *\n *  - declare INTENT, so \"we do not use Slack\" is a stated decision rather than\n *    something inferred from two empty URLs that look like an oversight;\n *  - gate the deploy-time check (`pb_check_alert_delivery`), which is what turns\n *    a half-configured channel into a refused deploy instead of a 3am surprise;\n *  - drive the posture gauges below, so a dashboard can answer \"is anyone\n *    actually going to hear this\" without reading four YAML files.\n *\n * The URLS THEMSELVES ARE NOT HERE, and that is deliberate. A Slack webhook URL\n * is a bearer credential: anyone holding it can post to the channel. Alertmanager\n * reads them from a mounted Secret via `api_url_file`, per notification, so they\n * never enter a ConfigMap and never enter this process. Platform knows WHETHER\n * Slack delivery is declared on; it does not know, and does not need, where to.\n * The pager's routing key is different — that one IS consumed by this process, so\n * it lives in `pagerDutyConfig()`.\n */\n\nimport { pagerDutyConfig } from './pagerduty.js';\nimport { envBool, envInt, envStr } from '../utils/env.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter, emitGauge } from '../utils/metric-emitter.js';\nimport { safeFetch } from '../utils/ssrf.js';\n\nconst logger = createLogger('alert-delivery');\n\nexport interface SlackAlertsConfig {\n  /**\n   * Whether ops-team Slack delivery is DECLARED on.\n   *\n   * Defaults FALSE, matching `ONCALL_ENABLED`: both destinations are opt-in, so\n   * a deployment states what it wants rather than inheriting a channel it may\n   * not have. Note what this flag does NOT do — it cannot remove the Slack\n   * receivers, because `alertmanager.yml` is asserted byte-identical across\n   * targets and Alertmanager has no templating. A deployment with the flag off\n   * and real URLs in its Secret still delivers to Slack.\n   */\n  enabled: boolean;\n  /**\n   * Whether Slack delivery CAN happen — i.e. the webhook URLs are non-empty.\n   *\n   * Derived at deploy time (`pb_check_alert_delivery` writes it) because the\n   * URLs live in Alertmanager's Secret and never enter this process: a Slack\n   * webhook URL is a bearer credential, read per notification via\n   * `api_url_file`. Platform therefore cannot inspect them and must be told.\n   *\n   * SEPARATE FROM `enabled` for the same reason the pager splits the two, and\n   * the distinction is what keeps `AlertDeliveryDisabled` honest. Keying that\n   * alert on the DECLARATION would page every deployment that left the flag at\n   * its default while Slack was quietly working — a false alarm on a healthy\n   * system, which is the fastest way to teach people to ignore an alert.\n   */\n  configured: boolean;\n}\n\nexport function slackAlertsConfig(): SlackAlertsConfig {\n  return {\n    enabled: envBool('SLACK_ALERTS_ENABLED', false),\n    configured: envBool('SLACK_ALERTS_CONFIGURED', false),\n  };\n}\n\n/** Both destinations, resolved together — what `reportAlertDeliveryPosture` reads. */\nexport interface AlertDeliveryConfig {\n  slack: SlackAlertsConfig;\n  pager: { enabled: boolean; configured: boolean };\n}\n\n/** Whether ANY destination could actually deliver — reality, not declaration. */\nexport function canDeliverAnywhere(cfg: AlertDeliveryConfig): boolean {\n  return cfg.slack.configured || (cfg.pager.enabled && cfg.pager.configured);\n}\n\nexport function alertDeliveryConfig(): AlertDeliveryConfig {\n  const pd = pagerDutyConfig();\n  return {\n    slack: slackAlertsConfig(),\n    // `configured` separately from `enabled`: enabled-without-a-key is the\n    // half-configured state worth seeing, and it is invisible if the two are\n    // collapsed into one boolean.\n    pager: { enabled: pd.enabled, configured: pd.routingKey.length > 0 },\n  };\n}\n\n/**\n * Publish the delivery posture as gauges, and shout if it is incoherent.\n *\n * Called once at boot. Gauges rather than counters because these are STATES of\n * the deployment — an operator wants \"will anyone hear an alert right now\", not\n * how many times a process started and wondered.\n *\n * The value of having this at all: before it, answering \"does this deployment\n * page anyone?\" meant reading `.env`, two Secrets and four copies of\n * `alertmanager.yml`. A deployment can now alert on its own inability to alert.\n */\nexport function reportAlertDeliveryPosture(cfg: AlertDeliveryConfig = alertDeliveryConfig()): void {\n  emitGauge('alert_delivery_enabled', { channel: 'slack' }, cfg.slack.enabled ? 1 : 0);\n  emitGauge('alert_delivery_enabled', { channel: 'pager' }, cfg.pager.enabled ? 1 : 0);\n  emitGauge('alert_delivery_configured', { channel: 'slack' }, cfg.slack.configured ? 1 : 0);\n  emitGauge('alert_delivery_configured', { channel: 'pager' }, cfg.pager.configured ? 1 : 0);\n\n  // Enabled with no credential: somebody asked for paging and is not getting it.\n  // The deploy check refuses this combination, so reaching here means it was\n  // changed after provisioning — which is exactly when nobody is looking.\n  if (cfg.pager.enabled && !cfg.pager.configured) {\n    logger.error('ONCALL_ENABLED is true but no PAGERDUTY_ROUTING_KEY is set — support criticals will not page');\n  }\n  // Nothing CAN deliver. Keyed on reachability rather than on the two flags,\n  // because the flags are declarations: a deployment that left both at their\n  // (false) defaults while real Slack URLs sit in its Secret is delivering\n  // fine, and warning it would be a lie.\n  if (!canDeliverAnywhere(cfg)) {\n    logger.warn('No platform alert destination is enabled — alerts will reach Alertmanager and go no further', {\n      hint: 'SLACK_ALERTS_ENABLED / ONCALL_ENABLED',\n    });\n  }\n}\n\n/**\n * The dead-man switch: a heartbeat whose ABSENCE is the alert.\n *\n * Every other alert in this system depends on something inside it still working.\n * This one inverts that — an external service expects a POST on a schedule and\n * raises an incident when one does not arrive, so a platform that is wedged,\n * crashed, partitioned or never started is reported BY ITS SILENCE. Nothing\n * inside a broken deployment has to notice its own brokenness.\n *\n * WHY IT IS BUILT HERE RATHER THAN BOUGHT, when the rest of on-call deliberately\n * is not: PagerDuty's heartbeat monitoring is an Event Orchestration pattern and\n * documented as AIOps-powered, so it may sit behind a tier and is not part of\n * Events v2. More importantly a dead-man switch is a CLOCK, not a telecom\n * problem — the thing that made the last mile worth buying (carrier retries,\n * delivery receipts, a 3am failure budget) simply does not apply to sending one\n * request on an interval. `ONCALL_DEADMAN_URL` therefore points wherever the\n * operator likes: PagerDuty's orchestration endpoint, a purpose-built dead-man\n * service, or an uptime monitor.\n *\n * TWO PROPERTIES WORTH STATING, because they are the reason this is safe:\n *\n *  - It is NOT leader-locked. A heartbeat is per-process on purpose: with three\n *    replicas, the external service hears from whichever are alive, and silence\n *    means ALL of them stopped. Leader-locking it would make the switch report\n *    the leader's health rather than the deployment's — and would make a Redis\n *    outage look identical to a total outage.\n *  - It fails SILENTLY on its own errors, deliberately. A heartbeat that logged\n *    an error every interval during a network blip would be its own noise\n *    source, and the consequence of a missed beat is already handled: the\n *    external service alerts. The only thing it must never do is report success\n *    it did not achieve, which is why nothing here swallows a non-2xx.\n */\nexport interface DeadmanConfig {\n  url: string;\n  intervalMs: number;\n}\n\nexport function deadmanConfig(): DeadmanConfig {\n  return {\n    url: envStr('ONCALL_DEADMAN_URL', ''),\n    intervalMs: envInt('ONCALL_DEADMAN_INTERVAL_MS', 60_000, { min: 1000 }),\n  };\n}\n\nlet deadmanTimer: NodeJS.Timeout | undefined;\n\n/**\n * Start beating. No-op when `ONCALL_DEADMAN_URL` is unset, which is the default:\n * an unconfigured dead-man switch must not beat against nothing, and must not\n * pretend it is covering the deployment.\n *\n * Returns true when a timer was started, so a caller can log the posture.\n */\nexport function startDeadmanHeartbeat(cfg: DeadmanConfig = deadmanConfig()): boolean {\n  if (deadmanTimer || !cfg.url) return false;\n  const beat = async (): Promise<void> => {\n    try {\n      const resp = await safeFetch(cfg.url, { method: 'POST', timeoutMs: 5000, body: '{}', headers: { 'Content-Type': 'application/json' } });\n      emitCounter('oncall_deadman_total', { outcome: resp.ok && !resp.redirected ? 'sent' : 'failed' });\n    } catch {\n      // Counted, never logged per-beat — see the module note on noise.\n      emitCounter('oncall_deadman_total', { outcome: 'failed' });\n    }\n  };\n  // `unref` so a pending beat cannot hold the process open during shutdown: the\n  // switch exists to report that the process STOPPED, and delaying that is\n  // precisely backwards.\n  deadmanTimer = setInterval(() => void beat(), cfg.intervalMs);\n  deadmanTimer.unref();\n  void beat();\n  return true;\n}\n\n/** Stop beating — called from the unified shutdown path, not a signal handler. */\nexport function stopDeadmanHeartbeat(): void {\n  if (deadmanTimer) clearInterval(deadmanTimer);\n  deadmanTimer = undefined;\n}\n"]}

package/lib/services/audit-context.d.ts

@@ -0,0 +1,105 @@
+import type { Request } from 'express';
+import type { JwtPayload } from '../types/common.js';
+/** Inbound correlation ids a caller (CLI, Lambda, CodeBuild) may forward. */
+export interface AuditCorrelation {
+    /** `X-Pipeline-Execution-Id` — the CodePipeline execution that made the call. */
+    pipelineExecutionId?: string;
+    /** `X-CodeBuild-Build-Id` — the CodeBuild build that made the call. */
+    codebuildBuildId?: string;
+    /** `X-Source-Event-Id` — the upstream event (EventBridge / webhook) being handled. */
+    sourceEventId?: string;
+}
+/** Background-work identity for events recorded outside any request. */
+export interface AuditJobContext {
+    /** Stable job name (e.g. `registry-gc`, `vuln-rescan`). */
+    jobId?: string;
+    /** This run's id (a BullMQ job id, a sweep's uuid). */
+    runId?: string;
+    /** What started it: `schedule`, `queue`, `startup`, `manual`, … */
+    trigger?: string;
+}
+export interface AuditContext {
+    requestId?: string;
+    traceId?: string;
+    ip?: string;
+    userAgent?: string;
+    correlation?: AuditCorrelation;
+    job?: AuditJobContext;
+    /**
+     * The VERIFIED principal of the inbound request. A getter, not a value: the
+     * scope opens before `requireAuth` runs, so `req.user` is read at the moment
+     * an event is recorded.
+     */
+    principal?: () => JwtPayload | undefined;
+}
+/**
+ * The credential behind an audited action — reserved `details._auth`, so it is
+ * covered by the audit hash chain (which hashes `details`). Built only from a
+ * verified token, never from caller input; the remote-audit client overwrites
+ * any `_auth` a call site put in `details`.
+ */
+export interface AuditAuthBlock {
+    principalType?: string;
+    /** The internal service, when the principal is a service token. */
+    service?: string;
+    /**
+     * The revocable credential: the access key (PAT / service-account key) the
+     * token derives from (`parentKeyId`), else the token's own `jti` (an exchanged
+     * key token's key id, an impersonation session id, a service mint id).
+     */
+    keyId?: string;
+    /** Refresh-session slot the token was minted on. */
+    sid?: string;
+    scope?: string;
+    tokenUse?: string;
+    /** The token's permissions were narrowed to a subset at credential creation. */
+    permissionsRestricted?: true;
+    /** The principal is a platform superadmin. */
+    superAdmin?: true;
+    /**
+     * The principal's active org is the system org (vendor staff acting through a
+     * system-org job Role). With `superAdmin`, this is what lets the remote-audit
+     * client claim a cross-org `affectedOrgId` (see `auditCrossOrg`).
+     */
+    systemOrg?: true;
+}
+/**
+ * Run `fn` inside an audit-context scope. Nested scopes MERGE onto the outer
+ * one (a job started inside a request keeps the request's id), with the inner
+ * fields winning.
+ */
+export declare function runWithAuditContext<T>(ctx: AuditContext, fn: () => T): T;
+/** The active audit context, or undefined outside any scope. */
+export declare function currentAuditContext(): AuditContext | undefined;
+/** Inbound correlation headers recorded into the audit context. */
+export declare const AUDIT_CORRELATION_HEADERS: {
+    readonly pipelineExecutionId: 'x-pipeline-execution-id';
+    readonly codebuildBuildId: 'x-codebuild-build-id';
+    readonly sourceEventId: 'x-source-event-id';
+};
+/**
+ * Validate an inbound correlation id (`X-Request-Id`, `X-CodeBuild-Build-Id`, …):
+ * a bounded opaque token, else `undefined` — an invalid value is dropped, never
+ * truncated into something that looks like a different id.
+ *
+ * No AWS account id is ever stored: an ARN (a CodeBuild build ARN, say) has its
+ * account segment emptied, and a bare 12-digit value is refused. The generic
+ * 12-digit-run scrub is NOT used here — it would redact the all-digit final
+ * group of roughly one uuid in three hundred, corrupting the id it exists to
+ * correlate.
+ */
+export declare function sanitizeCorrelationId(raw: unknown): string | undefined;
+/** Strip control characters from a User-Agent and cap its length; undefined when empty. */
+export declare function sanitizeUserAgent(raw: unknown): string | undefined;
+/**
+ * The audit context for an inbound request. `requestId` is the id the
+ * request-id middleware resolved (validated inbound `X-Request-Id`, else a fresh
+ * uuid); the principal is read lazily from `req.user` (auth runs later in the
+ * chain).
+ */
+export declare function auditContextFromRequest(req: Request, ids?: {
+    requestId?: string;
+    traceId?: string;
+}): AuditContext;
+/** The `_auth` block for a verified principal (undefined when there is none). */
+export declare function auditAuthBlock(user: JwtPayload | undefined): AuditAuthBlock | undefined;

package/lib/services/audit-context.js

@@ -0,0 +1,134 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Ambient audit context: the request/job facts every audit event should carry
+ * (request id, trace id, client ip / user agent, the verified principal's
+ * credential, inbound correlation ids) without each of the ~150 `recordAudit`
+ * call sites threading them through by hand.
+ *
+ * api-server's request pipeline opens a scope per inbound request
+ * (`auditContextFromRequest` + `runWithAuditContext`); background work opens its
+ * own with `runWithAuditContext({ job: { jobId, runId, trigger } }, fn)`. The
+ * remote-audit client reads the scope when an event is RECORDED and stamps the
+ * result onto the event itself, so a spooled re-delivery minutes later still
+ * carries the context of the moment it happened.
+ */
+import { AsyncLocalStorage } from 'async_hooks';
+import { serviceNameOf } from '../middleware/service-tokens.js';
+import { isSystemOrgId } from '../middleware/system-org.js';
+const storage = new AsyncLocalStorage();
+/**
+ * Run `fn` inside an audit-context scope. Nested scopes MERGE onto the outer
+ * one (a job started inside a request keeps the request's id), with the inner
+ * fields winning.
+ */
+export function runWithAuditContext(ctx, fn) {
+    const outer = storage.getStore();
+    const merged = outer
+        ? { ...outer, ...ctx, correlation: ctx.correlation ?? outer.correlation, job: ctx.job ? { ...outer.job, ...ctx.job } : outer.job }
+        : ctx;
+    return storage.run(merged, fn);
+}
+/** The active audit context, or undefined outside any scope. */
+export function currentAuditContext() {
+    return storage.getStore();
+}
+/** Inbound correlation headers recorded into the audit context. */
+export const AUDIT_CORRELATION_HEADERS = {
+    pipelineExecutionId: 'x-pipeline-execution-id',
+    codebuildBuildId: 'x-codebuild-build-id',
+    sourceEventId: 'x-source-event-id',
+};
+/** Max length of a stored correlation id / request id. */
+const MAX_CORRELATION_LEN = 128;
+/** Ids are opaque tokens: uuids, `project:uuid` build ids, ULIDs. Nothing else is stored. */
+const CORRELATION_ID = /^[A-Za-z0-9._:/@+=-]+$/;
+/** A bare AWS account id. */
+const BARE_ACCOUNT_ID = /^\d{12}$/;
+/** Max stored User-Agent length — a hostile header must not bloat audit rows. */
+const MAX_USER_AGENT_LEN = 512;
+/** C0 + DEL + C1 control characters, replaced so a UA can't inject into the UI/CSV export. */
+const CONTROL_CHARS = new RegExp('[\\u0000-\\u001f\\u007f-\\u009f]', 'g');
+function firstHeader(raw) {
+    return Array.isArray(raw) ? raw[0] : raw;
+}
+/**
+ * Validate an inbound correlation id (`X-Request-Id`, `X-CodeBuild-Build-Id`, …):
+ * a bounded opaque token, else `undefined` — an invalid value is dropped, never
+ * truncated into something that looks like a different id.
+ *
+ * No AWS account id is ever stored: an ARN (a CodeBuild build ARN, say) has its
+ * account segment emptied, and a bare 12-digit value is refused. The generic
+ * 12-digit-run scrub is NOT used here — it would redact the all-digit final
+ * group of roughly one uuid in three hundred, corrupting the id it exists to
+ * correlate.
+ */
+export function sanitizeCorrelationId(raw) {
+    if (typeof raw !== 'string')
+        return undefined;
+    const value = raw.trim();
+    if (value.length === 0 || value.length > MAX_CORRELATION_LEN || !CORRELATION_ID.test(value))
+        return undefined;
+    if (BARE_ACCOUNT_ID.test(value))
+        return undefined;
+    if (/^arn:/i.test(value)) {
+        const parts = value.split(':');
+        if (parts.length > 4)
+            parts[4] = '';
+        return parts.join(':');
+    }
+    return value;
+}
+/** Strip control characters from a User-Agent and cap its length; undefined when empty. */
+export function sanitizeUserAgent(raw) {
+    if (typeof raw !== 'string' || raw.length === 0)
+        return undefined;
+    const cleaned = raw.replace(CONTROL_CHARS, ' ').trim();
+    return cleaned.length === 0 ? undefined : cleaned.slice(0, MAX_USER_AGENT_LEN);
+}
+/**
+ * The audit context for an inbound request. `requestId` is the id the
+ * request-id middleware resolved (validated inbound `X-Request-Id`, else a fresh
+ * uuid); the principal is read lazily from `req.user` (auth runs later in the
+ * chain).
+ */
+export function auditContextFromRequest(req, ids = {}) {
+    const correlation = {};
+    for (const [field, header] of Object.entries(AUDIT_CORRELATION_HEADERS)) {
+        const value = sanitizeCorrelationId(firstHeader(req.headers[header]));
+        if (value)
+            correlation[field] = value;
+    }
+    return {
+        requestId: ids.requestId,
+        traceId: ids.traceId,
+        ip: req.ip,
+        userAgent: sanitizeUserAgent(firstHeader(req.headers['user-agent'])),
+        correlation: Object.keys(correlation).length > 0 ? correlation : undefined,
+        principal: () => req.user,
+    };
+}
+/** The `_auth` block for a verified principal (undefined when there is none). */
+export function auditAuthBlock(user) {
+    if (!user)
+        return undefined;
+    const block = {
+        principalType: user.principalType,
+        service: serviceNameOf(user),
+        keyId: user.parentKeyId ?? user.jti,
+        sid: user.sid,
+        scope: user.scope,
+        tokenUse: user.token_use,
+        ...(user.permissionsRestricted === true ? { permissionsRestricted: true } : {}),
+        ...(user.isSuperAdmin === true ? { superAdmin: true } : {}),
+        // A SERVICE token in the system org is the platform's own plumbing, not staff
+        // acting on a tenant; only human / service-account principals count.
+        ...(user.principalType !== 'service' && isSystemOrgId(user.organizationId) ? { systemOrg: true } : {}),
+    };
+    for (const key of Object.keys(block)) {
+        if (block[key] === undefined)
+            delete block[key];
+    }
+    return Object.keys(block).length > 0 ? block : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"audit-context.js","sourceRoot":"","sources":["../../src/services/audit-context.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Ambient audit context: the request/job facts every audit event should carry\n * (request id, trace id, client ip / user agent, the verified principal's\n * credential, inbound correlation ids) without each of the ~150 `recordAudit`\n * call sites threading them through by hand.\n *\n * api-server's request pipeline opens a scope per inbound request\n * (`auditContextFromRequest` + `runWithAuditContext`); background work opens its\n * own with `runWithAuditContext({ job: { jobId, runId, trigger } }, fn)`. The\n * remote-audit client reads the scope when an event is RECORDED and stamps the\n * result onto the event itself, so a spooled re-delivery minutes later still\n * carries the context of the moment it happened.\n */\n\nimport { AsyncLocalStorage } from 'async_hooks';\nimport type { Request } from 'express';\nimport { serviceNameOf } from '../middleware/service-tokens.js';\nimport { isSystemOrgId } from '../middleware/system-org.js';\nimport type { JwtPayload } from '../types/common.js';\n\n/** Inbound correlation ids a caller (CLI, Lambda, CodeBuild) may forward. */\nexport interface AuditCorrelation {\n  /** `X-Pipeline-Execution-Id` — the CodePipeline execution that made the call. */\n  pipelineExecutionId?: string;\n  /** `X-CodeBuild-Build-Id` — the CodeBuild build that made the call. */\n  codebuildBuildId?: string;\n  /** `X-Source-Event-Id` — the upstream event (EventBridge / webhook) being handled. */\n  sourceEventId?: string;\n}\n\n/** Background-work identity for events recorded outside any request. */\nexport interface AuditJobContext {\n  /** Stable job name (e.g. `registry-gc`, `vuln-rescan`). */\n  jobId?: string;\n  /** This run's id (a BullMQ job id, a sweep's uuid). */\n  runId?: string;\n  /** What started it: `schedule`, `queue`, `startup`, `manual`, … */\n  trigger?: string;\n}\n\nexport interface AuditContext {\n  requestId?: string;\n  traceId?: string;\n  ip?: string;\n  userAgent?: string;\n  correlation?: AuditCorrelation;\n  job?: AuditJobContext;\n  /**\n   * The VERIFIED principal of the inbound request. A getter, not a value: the\n   * scope opens before `requireAuth` runs, so `req.user` is read at the moment\n   * an event is recorded.\n   */\n  principal?: () => JwtPayload | undefined;\n}\n\n/**\n * The credential behind an audited action — reserved `details._auth`, so it is\n * covered by the audit hash chain (which hashes `details`). Built only from a\n * verified token, never from caller input; the remote-audit client overwrites\n * any `_auth` a call site put in `details`.\n */\nexport interface AuditAuthBlock {\n  principalType?: string;\n  /** The internal service, when the principal is a service token. */\n  service?: string;\n  /**\n   * The revocable credential: the access key (PAT / service-account key) the\n   * token derives from (`parentKeyId`), else the token's own `jti` (an exchanged\n   * key token's key id, an impersonation session id, a service mint id).\n   */\n  keyId?: string;\n  /** Refresh-session slot the token was minted on. */\n  sid?: string;\n  scope?: string;\n  tokenUse?: string;\n  /** The token's permissions were narrowed to a subset at credential creation. */\n  permissionsRestricted?: true;\n  /** The principal is a platform superadmin. */\n  superAdmin?: true;\n  /**\n   * The principal's active org is the system org (vendor staff acting through a\n   * system-org job Role). With `superAdmin`, this is what lets the remote-audit\n   * client claim a cross-org `affectedOrgId` (see `auditCrossOrg`).\n   */\n  systemOrg?: true;\n}\n\nconst storage = new AsyncLocalStorage<AuditContext>();\n\n/**\n * Run `fn` inside an audit-context scope. Nested scopes MERGE onto the outer\n * one (a job started inside a request keeps the request's id), with the inner\n * fields winning.\n */\nexport function runWithAuditContext<T>(ctx: AuditContext, fn: () => T): T {\n  const outer = storage.getStore();\n  const merged: AuditContext = outer\n    ? { ...outer, ...ctx, correlation: ctx.correlation ?? outer.correlation, job: ctx.job ? { ...outer.job, ...ctx.job } : outer.job }\n    : ctx;\n  return storage.run(merged, fn);\n}\n\n/** The active audit context, or undefined outside any scope. */\nexport function currentAuditContext(): AuditContext | undefined {\n  return storage.getStore();\n}\n\n/** Inbound correlation headers recorded into the audit context. */\nexport const AUDIT_CORRELATION_HEADERS = {\n  pipelineExecutionId: 'x-pipeline-execution-id',\n  codebuildBuildId: 'x-codebuild-build-id',\n  sourceEventId: 'x-source-event-id',\n} as const;\n\n/** Max length of a stored correlation id / request id. */\nconst MAX_CORRELATION_LEN = 128;\n/** Ids are opaque tokens: uuids, `project:uuid` build ids, ULIDs. Nothing else is stored. */\nconst CORRELATION_ID = /^[A-Za-z0-9._:/@+=-]+$/;\n/** A bare AWS account id. */\nconst BARE_ACCOUNT_ID = /^\\d{12}$/;\n\n/** Max stored User-Agent length — a hostile header must not bloat audit rows. */\nconst MAX_USER_AGENT_LEN = 512;\n/** C0 + DEL + C1 control characters, replaced so a UA can't inject into the UI/CSV export. */\nconst CONTROL_CHARS = new RegExp('[\\\\u0000-\\\\u001f\\\\u007f-\\\\u009f]', 'g');\n\nfunction firstHeader(raw: string | string[] | undefined): string | undefined {\n  return Array.isArray(raw) ? raw[0] : raw;\n}\n\n/**\n * Validate an inbound correlation id (`X-Request-Id`, `X-CodeBuild-Build-Id`, …):\n * a bounded opaque token, else `undefined` — an invalid value is dropped, never\n * truncated into something that looks like a different id.\n *\n * No AWS account id is ever stored: an ARN (a CodeBuild build ARN, say) has its\n * account segment emptied, and a bare 12-digit value is refused. The generic\n * 12-digit-run scrub is NOT used here — it would redact the all-digit final\n * group of roughly one uuid in three hundred, corrupting the id it exists to\n * correlate.\n */\nexport function sanitizeCorrelationId(raw: unknown): string | undefined {\n  if (typeof raw !== 'string') return undefined;\n  const value = raw.trim();\n  if (value.length === 0 || value.length > MAX_CORRELATION_LEN || !CORRELATION_ID.test(value)) return undefined;\n  if (BARE_ACCOUNT_ID.test(value)) return undefined;\n  if (/^arn:/i.test(value)) {\n    const parts = value.split(':');\n    if (parts.length > 4) parts[4] = '';\n    return parts.join(':');\n  }\n  return value;\n}\n\n/** Strip control characters from a User-Agent and cap its length; undefined when empty. */\nexport function sanitizeUserAgent(raw: unknown): string | undefined {\n  if (typeof raw !== 'string' || raw.length === 0) return undefined;\n  const cleaned = raw.replace(CONTROL_CHARS, ' ').trim();\n  return cleaned.length === 0 ? undefined : cleaned.slice(0, MAX_USER_AGENT_LEN);\n}\n\n/**\n * The audit context for an inbound request. `requestId` is the id the\n * request-id middleware resolved (validated inbound `X-Request-Id`, else a fresh\n * uuid); the principal is read lazily from `req.user` (auth runs later in the\n * chain).\n */\nexport function auditContextFromRequest(req: Request, ids: { requestId?: string; traceId?: string } = {}): AuditContext {\n  const correlation: AuditCorrelation = {};\n  for (const [field, header] of Object.entries(AUDIT_CORRELATION_HEADERS) as Array<[keyof AuditCorrelation, string]>) {\n    const value = sanitizeCorrelationId(firstHeader(req.headers[header]));\n    if (value) correlation[field] = value;\n  }\n  return {\n    requestId: ids.requestId,\n    traceId: ids.traceId,\n    ip: req.ip,\n    userAgent: sanitizeUserAgent(firstHeader(req.headers['user-agent'])),\n    correlation: Object.keys(correlation).length > 0 ? correlation : undefined,\n    principal: () => req.user,\n  };\n}\n\n/** The `_auth` block for a verified principal (undefined when there is none). */\nexport function auditAuthBlock(user: JwtPayload | undefined): AuditAuthBlock | undefined {\n  if (!user) return undefined;\n  const block: AuditAuthBlock = {\n    principalType: user.principalType,\n    service: serviceNameOf(user),\n    keyId: user.parentKeyId ?? user.jti,\n    sid: user.sid,\n    scope: user.scope,\n    tokenUse: user.token_use,\n    ...(user.permissionsRestricted === true ? { permissionsRestricted: true as const } : {}),\n    ...(user.isSuperAdmin === true ? { superAdmin: true as const } : {}),\n    // A SERVICE token in the system org is the platform's own plumbing, not staff\n    // acting on a tenant; only human / service-account principals count.\n    ...(user.principalType !== 'service' && isSystemOrgId(user.organizationId) ? { systemOrg: true as const } : {}),\n  };\n  for (const key of Object.keys(block) as Array<keyof AuditAuthBlock>) {\n    if (block[key] === undefined) delete block[key];\n  }\n  return Object.keys(block).length > 0 ? block : undefined;\n}\n"]}