@pipeline-builder/api-core 5.2.2 → 5.2.4

package/lib/services/pagerduty-inbound.js

@@ -0,0 +1,195 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The INBOUND half of on-call: what the provider tells us back.
+ *
+ * Everything else in this feature pushes outward — an alert fires, a case
+ * approaches its deadline, an event goes to Events v2. That direction can only
+ * ever report that a page was ACCEPTED, which is a 202 and not a phone ringing.
+ * This module is the only source of the two facts that actually matter:
+ *
+ *  - SOMEBODY PICKED IT UP, and who. `oncall_pages_total{outcome="accepted"}`
+ *    cannot answer "was anyone awake at 03:14"; an acknowledgement can, and
+ *    bound to a user id it becomes an audit record rather than a hint. The
+ *    provider's own ack view is not auditable here — a click on a link in their
+ *    UI is not an identity this system can attest to — so the webhook is what
+ *    turns their state change into our record.
+ *  - NOBODY IS SCHEDULED. A rota with a hole next Tuesday has to be visible on
+ *    MONDAY, not at 02:00 Tuesday. That is an absence check, and absence checks
+ *    are the ones this codebase keeps finding it had missed. It is answered by
+ *    READING the provider's schedule rather than owning one.
+ *
+ * TWO CREDENTIALS, DELIBERATELY SEPARATE AND BOTH OPTIONAL.
+ * `PAGERDUTY_WEBHOOK_SECRET` verifies what they send us. `PAGERDUTY_API_TOKEN`
+ * is a REST token for reading the rota and is strictly more powerful than the
+ * per-service integration key used for sending — an integration key can only
+ * create events on one service, while a REST token reads incidents, schedules
+ * and users account-wide. So the rota check is opt-in on its own credential,
+ * and a deployment that does not want to hand over a REST token simply does not
+ * get the gauge. It must never be inferred from the routing key.
+ */
+import { createHmac, timingSafeEqual } from 'crypto';
+import { envInt, envStr } from '../utils/env.js';
+import { createLogger } from '../utils/logger.js';
+import { errorMessage } from '../utils/response.js';
+import { safeFetch } from '../utils/ssrf.js';
+const logger = createLogger('pagerduty-inbound');
+export const PAGERDUTY_API_URL = 'https://api.pagerduty.com';
+/**
+ * Verify a PagerDuty v3 webhook signature.
+ *
+ * The scheme: `X-PagerDuty-Signature: v1=<lowercase hex>`, an HMAC-SHA256 over
+ * the RAW request body. Three properties of it are easy to get wrong and each
+ * one is a hole:
+ *
+ *  - THE RAW BODY, not a re-serialized object. `JSON.stringify(req.body)` after
+ *    a JSON parser has run produces different bytes (key order, whitespace,
+ *    number formatting), so every signature fails and the obvious "fix" is to
+ *    stop checking. The route therefore mounts `express.raw`.
+ *  - MULTIPLE SIGNATURES. The header may carry several comma-separated `v1=`
+ *    values, which is how PagerDuty rotates a secret without downtime. Checking
+ *    only the first breaks during their rotation, so ANY match is accepted —
+ *    the same overlap this repo already runs for its own relay token.
+ *  - CONSTANT TIME. Compared with `timingSafeEqual` on equal-length buffers,
+ *    because a byte-at-a-time comparison leaks the expected digest to anyone
+ *    who can post here repeatedly.
+ *
+ * NO SECRET MEANS NO. An unverified webhook that moves an audit record and a
+ * metric is a way for anyone who learns the URL to assert that a page was
+ * handled — the one lie that would make the whole feature report coverage it
+ * does not have. Fails closed.
+ */
+export function verifyPagerDutySignature(rawBody, header, secret) {
+    if (!secret || !header)
+        return false;
+    const expected = createHmac('sha256', secret).update(rawBody).digest('hex');
+    const expectedBuf = Buffer.from(expected, 'utf8');
+    for (const part of header.split(',')) {
+        const value = part.trim();
+        if (!value.startsWith('v1='))
+            continue;
+        const given = Buffer.from(value.slice(3), 'utf8');
+        // Length-guarded: timingSafeEqual THROWS on a length mismatch, and an
+        // attacker controls this length.
+        if (given.length === expectedBuf.length && timingSafeEqual(given, expectedBuf))
+            return true;
+    }
+    return false;
+}
+export function onCallInboundConfig() {
+    return {
+        webhookSecret: envStr('PAGERDUTY_WEBHOOK_SECRET', ''),
+        apiToken: envStr('PAGERDUTY_API_TOKEN', ''),
+        apiUrl: envStr('PAGERDUTY_API_URL', PAGERDUTY_API_URL),
+        // 48 hours: far enough to catch a hole over a weekend on the Friday, and
+        // short enough that a rota maintained a week out does not alert forever.
+        lookaheadHours: envInt('ONCALL_SCHEDULE_GAP_LOOKAHEAD_HOURS', 48, { min: 1, max: 2160 }),
+        escalationPolicyIds: envStr('PAGERDUTY_ESCALATION_POLICY_IDS', '')
+            .split(',').map((x) => x.trim()).filter(Boolean),
+        timeoutMs: envInt('ONCALL_EVENTS_TIMEOUT_MS', 5000, { min: 1 }),
+    };
+}
+/**
+ * Ask the provider whether anyone is on call across the lookahead window.
+ *
+ * WHAT THIS CAN AND CANNOT CONCLUDE, because the difference decides whether the
+ * alert built on it is honest. `GET /oncalls?since&until` returns the on-call
+ * entries OVERLAPPING a window; it does not return the holes. Reconstructing
+ * exact holes would mean stitching every entry's interval, and an entry's
+ * `start`/`end` are null for an always-on policy — so a precise
+ * "uncovered seconds" is not available from this endpoint without a lot of
+ * arithmetic that would be wrong in the always-on case.
+ *
+ * So this answers the question it CAN answer exactly: is the window covered at
+ * all. Zero entries over the next N hours means nobody is scheduled, which is
+ * the failure worth paging about and the one a rota maintainer actually makes.
+ * `uncoveredSeconds` is therefore the whole window or nothing, and it is a
+ * deliberate under-report rather than a guess — a partial hole reads as covered
+ * here, and claiming otherwise would be inventing precision.
+ *
+ * `known: false` when there is no API token or the call fails, and the caller
+ * must publish NOTHING in that case. A gauge of 0 would say "fully covered",
+ * which is exactly the lie this check exists to prevent.
+ */
+export async function fetchRotaCoverage(cfg = onCallInboundConfig()) {
+    const windowSeconds = cfg.lookaheadHours * 3600;
+    if (!cfg.apiToken)
+        return { known: false, entries: 0, uncoveredSeconds: 0 };
+    const since = new Date();
+    const until = new Date(since.getTime() + windowSeconds * 1000);
+    const params = new URLSearchParams({
+        since: since.toISOString(),
+        until: until.toISOString(),
+        limit: '50',
+    });
+    for (const id of cfg.escalationPolicyIds)
+        params.append('escalation_policy_ids[]', id);
+    try {
+        const resp = await safeFetch(`${cfg.apiUrl}/oncalls?${params.toString()}`, {
+            method: 'GET',
+            headers: {
+                // PagerDuty's REST scheme. `Accept` pins the API version; without it
+                // the response shape is whatever their default happens to be.
+                Authorization: `Token token=${cfg.apiToken}`,
+                Accept: 'application/vnd.pagerduty+json;version=2',
+            },
+            timeoutMs: cfg.timeoutMs,
+        });
+        if (resp.redirected || !resp.ok) {
+            logger.warn('Could not read the on-call rota', { status: resp.status, redirected: resp.redirected });
+            return { known: false, entries: 0, uncoveredSeconds: 0 };
+        }
+        const body = await resp.json();
+        const entries = Array.isArray(body.oncalls) ? body.oncalls.length : 0;
+        return { known: true, entries, uncoveredSeconds: entries > 0 ? 0 : windowSeconds };
+    }
+    catch (err) {
+        logger.warn('Could not reach the on-call rota API', { error: errorMessage(err) });
+        return { known: false, entries: 0, uncoveredSeconds: 0 };
+    }
+}
+/**
+ * Reduce a v3 webhook body to the fields this system uses.
+ *
+ * Returns `null` for anything that is not a recognised incident event, which
+ * the caller COUNTS rather than drops silently — an unrecognised event type is
+ * usually a subscription configured wider than the handler, and a count is how
+ * that becomes visible instead of being inferred from nothing happening.
+ */
+export function parseOnCallWebhook(body) {
+    const event = body?.event;
+    if (!event || typeof event.event_type !== 'string')
+        return null;
+    const data = (event.data ?? {});
+    const agency = (event.agent ?? {});
+    return {
+        eventType: event.event_type,
+        incidentId: typeof data.id === 'string' ? data.id : undefined,
+        // PagerDuty echoes the trigger's dedup_key on the incident, which is the
+        // only link back to WHICH case or alert this was — their incident id is
+        // theirs and means nothing on this side.
+        dedupKey: typeof data.dedup_key === 'string' ? data.dedup_key : undefined,
+        agentId: typeof agency.id === 'string' ? agency.id : undefined,
+        agentSummary: typeof agency.summary === 'string' ? agency.summary : undefined,
+        createdAt: typeof data.created_at === 'string' ? data.created_at : undefined,
+        occurredAt: typeof event.occurred_at === 'string' ? event.occurred_at : undefined,
+    };
+}
+/**
+ * Seconds between the incident being raised and this event.
+ *
+ * Returns `undefined` rather than 0 when either timestamp is missing or the
+ * arithmetic is nonsense: a 0 would land in the first histogram bucket and read
+ * as an instant acknowledgement, which is the most flattering possible lie
+ * about response time.
+ */
+export function ackLatencySeconds(event) {
+    if (!event.createdAt || !event.occurredAt)
+        return undefined;
+    const from = new Date(event.createdAt).getTime();
+    const to = new Date(event.occurredAt).getTime();
+    if (!Number.isFinite(from) || !Number.isFinite(to) || to < from)
+        return undefined;
+    return (to - from) / 1000;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagerduty-inbound.js","sourceRoot":"","sources":["../../src/services/pagerduty-inbound.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AACrD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,MAAM,MAAM,GAAG,YAAY,CAAC,mBAAmB,CAAC,CAAC;AAEjD,MAAM,CAAC,MAAM,iBAAiB,GAAG,2BAA2B,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,wBAAwB,CAAC,OAAwB,EAAE,MAA0B,EAAE,MAAc;IAC3G,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM;QAAE,OAAO,KAAK,CAAC;IACrC,MAAM,QAAQ,GAAG,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC5E,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAClD,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QACrC,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;QAC1B,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC;YAAE,SAAS;QACvC,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;QAClD,sEAAsE;QACtE,iCAAiC;QACjC,IAAI,KAAK,CAAC,MAAM,KAAK,WAAW,CAAC,MAAM,IAAI,eAAe,CAAC,KAAK,EAAE,WAAW,CAAC;YAAE,OAAO,IAAI,CAAC;IAC9F,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAaD,MAAM,UAAU,mBAAmB;IACjC,OAAO;QACL,aAAa,EAAE,MAAM,CAAC,0BAA0B,EAAE,EAAE,CAAC;QACrD,QAAQ,EAAE,MAAM,CAAC,qBAAqB,EAAE,EAAE,CAAC;QAC3C,MAAM,EAAE,MAAM,CAAC,mBAAmB,EAAE,iBAAiB,CAAC;QACtD,yEAAyE;QACzE,yEAAyE;QACzE,cAAc,EAAE,MAAM,CAAC,qCAAqC,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC;QACxF,mBAAmB,EAAE,MAAM,CAAC,iCAAiC,EAAE,EAAE,CAAC;aAC/D,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC;QAClD,SAAS,EAAE,MAAM,CAAC,0BAA0B,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC;KAChE,CAAC;AACJ,CAAC;AAWD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,GAAG,GAAwB,mBAAmB,EAAE;IACtF,MAAM,aAAa,GAAG,GAAG,CAAC,cAAc,GAAG,IAAI,CAAC;IAChD,IAAI,CAAC,GAAG,CAAC,QAAQ;QAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,gBAAgB,EAAE,CAAC,EAAE,CAAC;IAE5E,MAAM,KAAK,GAAG,IAAI,IAAI,EAAE,CAAC;IACzB,MAAM,KAAK,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,GAAG,aAAa,GAAG,IAAI,CAAC,CAAC;IAC/D,MAAM,MAAM,GAAG,IAAI,eAAe,CAAC;QACjC,KAAK,EAAE,KAAK,CAAC,WAAW,EAAE;QAC1B,KAAK,EAAE,KAAK,CAAC,WAAW,EAAE;QAC1B,KAAK,EAAE,IAAI;KACZ,CAAC,CAAC;IACH,KAAK,MAAM,EAAE,IAAI,GAAG,CAAC,mBAAmB;QAAE,MAAM,CAAC,MAAM,CAAC,yBAAyB,EAAE,EAAE,CAAC,CAAC;IAEvF,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,MAAM,SAAS,CAAC,GAAG,GAAG,CAAC,MAAM,YAAY,MAAM,CAAC,QAAQ,EAAE,EAAE,EAAE;YACzE,MAAM,EAAE,KAAK;YACb,OAAO,EAAE;gBACP,qEAAqE;gBACrE,8DAA8D;gBAC9D,aAAa,EAAE,eAAe,GAAG,CAAC,QAAQ,EAAE;gBAC5C,MAAM,EAAE,0CAA0C;aACnD;YACD,SAAS,EAAE,GAAG,CAAC,SAAS;SACzB,CAAC,CAAC;QACH,IAAI,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC;YAChC,MAAM,CAAC,IAAI,CAAC,iCAAiC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;YACrG,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,gBAAgB,EAAE,CAAC,EAAE,CAAC;QAC3D,CAAC;QACD,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,IAAI,EAA6B,CAAC;QAC1D,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QACtE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,gBAAgB,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,aAAa,EAAE,CAAC;IACrF,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,IAAI,CAAC,sCAAsC,EAAE,EAAE,KAAK,EAAE,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAClF,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,gBAAgB,EAAE,CAAC,EAAE,CAAC;IAC3D,CAAC;AACH,CAAC;AAuBD;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAa;IAC9C,MAAM,KAAK,GAAI,IAA4C,EAAE,KAAK,CAAC;IACnE,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,CAAC,UAAU,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IAChE,MAAM,IAAI,GAAG,CAAC,KAAK,CAAC,IAAI,IAAI,EAAE,CAA4B,CAAC;IAC3D,MAAM,MAAM,GAAG,CAAC,KAAK,CAAC,KAAK,IAAI,EAAE,CAA4B,CAAC;IAC9D,OAAO;QACL,SAAS,EAAE,KAAK,CAAC,UAAU;QAC3B,UAAU,EAAE,OAAO,IAAI,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS;QAC7D,yEAAyE;QACzE,wEAAwE;QACxE,yCAAyC;QACzC,QAAQ,EAAE,OAAO,IAAI,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS;QACzE,OAAO,EAAE,OAAO,MAAM,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS;QAC9D,YAAY,EAAE,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS;QAC7E,SAAS,EAAE,OAAO,IAAI,CAAC,UAAU,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS;QAC5E,UAAU,EAAE,OAAO,KAAK,CAAC,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS;KAClF,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAyB;IACzD,IAAI,CAAC,KAAK,CAAC,SAAS,IAAI,CAAC,KAAK,CAAC,UAAU;QAAE,OAAO,SAAS,CAAC;IAC5D,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,CAAC;IACjD,MAAM,EAAE,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,OAAO,EAAE,CAAC;IAChD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,IAAI;QAAE,OAAO,SAAS,CAAC;IAClF,OAAO,CAAC,EAAE,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;AAC5B,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The INBOUND half of on-call: what the provider tells us back.\n *\n * Everything else in this feature pushes outward — an alert fires, a case\n * approaches its deadline, an event goes to Events v2. That direction can only\n * ever report that a page was ACCEPTED, which is a 202 and not a phone ringing.\n * This module is the only source of the two facts that actually matter:\n *\n *  - SOMEBODY PICKED IT UP, and who. `oncall_pages_total{outcome=\"accepted\"}`\n *    cannot answer \"was anyone awake at 03:14\"; an acknowledgement can, and\n *    bound to a user id it becomes an audit record rather than a hint. The\n *    provider's own ack view is not auditable here — a click on a link in their\n *    UI is not an identity this system can attest to — so the webhook is what\n *    turns their state change into our record.\n *  - NOBODY IS SCHEDULED. A rota with a hole next Tuesday has to be visible on\n *    MONDAY, not at 02:00 Tuesday. That is an absence check, and absence checks\n *    are the ones this codebase keeps finding it had missed. It is answered by\n *    READING the provider's schedule rather than owning one.\n *\n * TWO CREDENTIALS, DELIBERATELY SEPARATE AND BOTH OPTIONAL.\n * `PAGERDUTY_WEBHOOK_SECRET` verifies what they send us. `PAGERDUTY_API_TOKEN`\n * is a REST token for reading the rota and is strictly more powerful than the\n * per-service integration key used for sending — an integration key can only\n * create events on one service, while a REST token reads incidents, schedules\n * and users account-wide. So the rota check is opt-in on its own credential,\n * and a deployment that does not want to hand over a REST token simply does not\n * get the gauge. It must never be inferred from the routing key.\n */\n\nimport { createHmac, timingSafeEqual } from 'crypto';\nimport { envInt, envStr } from '../utils/env.js';\nimport { createLogger } from '../utils/logger.js';\nimport { errorMessage } from '../utils/response.js';\nimport { safeFetch } from '../utils/ssrf.js';\n\nconst logger = createLogger('pagerduty-inbound');\n\nexport const PAGERDUTY_API_URL = 'https://api.pagerduty.com';\n\n/**\n * Verify a PagerDuty v3 webhook signature.\n *\n * The scheme: `X-PagerDuty-Signature: v1=<lowercase hex>`, an HMAC-SHA256 over\n * the RAW request body. Three properties of it are easy to get wrong and each\n * one is a hole:\n *\n *  - THE RAW BODY, not a re-serialized object. `JSON.stringify(req.body)` after\n *    a JSON parser has run produces different bytes (key order, whitespace,\n *    number formatting), so every signature fails and the obvious \"fix\" is to\n *    stop checking. The route therefore mounts `express.raw`.\n *  - MULTIPLE SIGNATURES. The header may carry several comma-separated `v1=`\n *    values, which is how PagerDuty rotates a secret without downtime. Checking\n *    only the first breaks during their rotation, so ANY match is accepted —\n *    the same overlap this repo already runs for its own relay token.\n *  - CONSTANT TIME. Compared with `timingSafeEqual` on equal-length buffers,\n *    because a byte-at-a-time comparison leaks the expected digest to anyone\n *    who can post here repeatedly.\n *\n * NO SECRET MEANS NO. An unverified webhook that moves an audit record and a\n * metric is a way for anyone who learns the URL to assert that a page was\n * handled — the one lie that would make the whole feature report coverage it\n * does not have. Fails closed.\n */\nexport function verifyPagerDutySignature(rawBody: Buffer | string, header: string | undefined, secret: string): boolean {\n  if (!secret || !header) return false;\n  const expected = createHmac('sha256', secret).update(rawBody).digest('hex');\n  const expectedBuf = Buffer.from(expected, 'utf8');\n  for (const part of header.split(',')) {\n    const value = part.trim();\n    if (!value.startsWith('v1=')) continue;\n    const given = Buffer.from(value.slice(3), 'utf8');\n    // Length-guarded: timingSafeEqual THROWS on a length mismatch, and an\n    // attacker controls this length.\n    if (given.length === expectedBuf.length && timingSafeEqual(given, expectedBuf)) return true;\n  }\n  return false;\n}\n\nexport interface OnCallInboundConfig {\n  webhookSecret: string;\n  apiToken: string;\n  apiUrl: string;\n  /** How far ahead the rota check looks. The gap alert is only as useful as this. */\n  lookaheadHours: number;\n  /** Escalation policy ids to check coverage for; empty means the whole account. */\n  escalationPolicyIds: string[];\n  timeoutMs: number;\n}\n\nexport function onCallInboundConfig(): OnCallInboundConfig {\n  return {\n    webhookSecret: envStr('PAGERDUTY_WEBHOOK_SECRET', ''),\n    apiToken: envStr('PAGERDUTY_API_TOKEN', ''),\n    apiUrl: envStr('PAGERDUTY_API_URL', PAGERDUTY_API_URL),\n    // 48 hours: far enough to catch a hole over a weekend on the Friday, and\n    // short enough that a rota maintained a week out does not alert forever.\n    lookaheadHours: envInt('ONCALL_SCHEDULE_GAP_LOOKAHEAD_HOURS', 48, { min: 1, max: 2160 }),\n    escalationPolicyIds: envStr('PAGERDUTY_ESCALATION_POLICY_IDS', '')\n      .split(',').map((x) => x.trim()).filter(Boolean),\n    timeoutMs: envInt('ONCALL_EVENTS_TIMEOUT_MS', 5000, { min: 1 }),\n  };\n}\n\nexport interface RotaCoverage {\n  /** Whether the question could be answered at all. */\n  known: boolean;\n  /** Distinct on-call entries covering any part of the window. */\n  entries: number;\n  /** Seconds of the lookahead window with nobody on call, 0 when fully covered. */\n  uncoveredSeconds: number;\n}\n\n/**\n * Ask the provider whether anyone is on call across the lookahead window.\n *\n * WHAT THIS CAN AND CANNOT CONCLUDE, because the difference decides whether the\n * alert built on it is honest. `GET /oncalls?since&until` returns the on-call\n * entries OVERLAPPING a window; it does not return the holes. Reconstructing\n * exact holes would mean stitching every entry's interval, and an entry's\n * `start`/`end` are null for an always-on policy — so a precise\n * \"uncovered seconds\" is not available from this endpoint without a lot of\n * arithmetic that would be wrong in the always-on case.\n *\n * So this answers the question it CAN answer exactly: is the window covered at\n * all. Zero entries over the next N hours means nobody is scheduled, which is\n * the failure worth paging about and the one a rota maintainer actually makes.\n * `uncoveredSeconds` is therefore the whole window or nothing, and it is a\n * deliberate under-report rather than a guess — a partial hole reads as covered\n * here, and claiming otherwise would be inventing precision.\n *\n * `known: false` when there is no API token or the call fails, and the caller\n * must publish NOTHING in that case. A gauge of 0 would say \"fully covered\",\n * which is exactly the lie this check exists to prevent.\n */\nexport async function fetchRotaCoverage(cfg: OnCallInboundConfig = onCallInboundConfig()): Promise<RotaCoverage> {\n  const windowSeconds = cfg.lookaheadHours * 3600;\n  if (!cfg.apiToken) return { known: false, entries: 0, uncoveredSeconds: 0 };\n\n  const since = new Date();\n  const until = new Date(since.getTime() + windowSeconds * 1000);\n  const params = new URLSearchParams({\n    since: since.toISOString(),\n    until: until.toISOString(),\n    limit: '50',\n  });\n  for (const id of cfg.escalationPolicyIds) params.append('escalation_policy_ids[]', id);\n\n  try {\n    const resp = await safeFetch(`${cfg.apiUrl}/oncalls?${params.toString()}`, {\n      method: 'GET',\n      headers: {\n        // PagerDuty's REST scheme. `Accept` pins the API version; without it\n        // the response shape is whatever their default happens to be.\n        Authorization: `Token token=${cfg.apiToken}`,\n        Accept: 'application/vnd.pagerduty+json;version=2',\n      },\n      timeoutMs: cfg.timeoutMs,\n    });\n    if (resp.redirected || !resp.ok) {\n      logger.warn('Could not read the on-call rota', { status: resp.status, redirected: resp.redirected });\n      return { known: false, entries: 0, uncoveredSeconds: 0 };\n    }\n    const body = await resp.json() as { oncalls?: unknown[] };\n    const entries = Array.isArray(body.oncalls) ? body.oncalls.length : 0;\n    return { known: true, entries, uncoveredSeconds: entries > 0 ? 0 : windowSeconds };\n  } catch (err) {\n    logger.warn('Could not reach the on-call rota API', { error: errorMessage(err) });\n    return { known: false, entries: 0, uncoveredSeconds: 0 };\n  }\n}\n\n/** The webhook events this system acts on. Everything else is counted and dropped. */\nexport type OnCallWebhookEventType =\n  | 'incident.acknowledged'\n  | 'incident.escalated'\n  | 'incident.resolved'\n  | 'incident.unacknowledged';\n\nexport interface OnCallWebhookEvent {\n  eventType: string;\n  /** Provider incident id — the join back to what we sent. */\n  incidentId?: string;\n  /** Our own `dedup_key`, when the provider echoes it. */\n  dedupKey?: string;\n  /** Who acted, as the provider knows them. An id and an email, never a session. */\n  agentId?: string;\n  agentSummary?: string;\n  /** When the incident was created, for the ack-latency measurement. */\n  createdAt?: string;\n  occurredAt?: string;\n}\n\n/**\n * Reduce a v3 webhook body to the fields this system uses.\n *\n * Returns `null` for anything that is not a recognised incident event, which\n * the caller COUNTS rather than drops silently — an unrecognised event type is\n * usually a subscription configured wider than the handler, and a count is how\n * that becomes visible instead of being inferred from nothing happening.\n */\nexport function parseOnCallWebhook(body: unknown): OnCallWebhookEvent | null {\n  const event = (body as { event?: Record<string, unknown> })?.event;\n  if (!event || typeof event.event_type !== 'string') return null;\n  const data = (event.data ?? {}) as Record<string, unknown>;\n  const agency = (event.agent ?? {}) as Record<string, unknown>;\n  return {\n    eventType: event.event_type,\n    incidentId: typeof data.id === 'string' ? data.id : undefined,\n    // PagerDuty echoes the trigger's dedup_key on the incident, which is the\n    // only link back to WHICH case or alert this was — their incident id is\n    // theirs and means nothing on this side.\n    dedupKey: typeof data.dedup_key === 'string' ? data.dedup_key : undefined,\n    agentId: typeof agency.id === 'string' ? agency.id : undefined,\n    agentSummary: typeof agency.summary === 'string' ? agency.summary : undefined,\n    createdAt: typeof data.created_at === 'string' ? data.created_at : undefined,\n    occurredAt: typeof event.occurred_at === 'string' ? event.occurred_at : undefined,\n  };\n}\n\n/**\n * Seconds between the incident being raised and this event.\n *\n * Returns `undefined` rather than 0 when either timestamp is missing or the\n * arithmetic is nonsense: a 0 would land in the first histogram bucket and read\n * as an instant acknowledgement, which is the most flattering possible lie\n * about response time.\n */\nexport function ackLatencySeconds(event: OnCallWebhookEvent): number | undefined {\n  if (!event.createdAt || !event.occurredAt) return undefined;\n  const from = new Date(event.createdAt).getTime();\n  const to = new Date(event.occurredAt).getTime();\n  if (!Number.isFinite(from) || !Number.isFinite(to) || to < from) return undefined;\n  return (to - from) / 1000;\n}\n"]}

package/lib/services/pagerduty.d.ts

@@ -0,0 +1,109 @@
+/** PagerDuty's own severity enum. Ours map straight onto it. */
+export type PagerDutySeverity = 'critical' | 'error' | 'warning' | 'info';
+/** The three follow-up actions a single `dedupKey` moves through. */
+export type PagerDutyAction = 'trigger' | 'acknowledge' | 'resolve';
+export interface PagerDutyEvent {
+    /**
+     * The key that ties a trigger to its later acknowledge/resolve. Stable and
+     * derived, never random: `case:<caseId>` for the per-case sweep,
+     * Alertmanager's own group fingerprint for the alert leg — so its grouping and
+     * ours cannot fight over the same incident.
+     */
+    dedupKey: string;
+    action: PagerDutyAction;
+    /**
+     * WHICH leg raised this, as a metric dimension only — never sent to PagerDuty.
+     *
+     * The two legs have different failure modes and must be separable in one
+     * counter: `alertmanager` depends on Prometheus evaluating and Alertmanager
+     * delivering, `case` depends on this product's own sweep being alive. Collapsed
+     * into one series, a dead sweep is invisible for as long as the fleet alert
+     * still fires — which is precisely the window the per-case trigger exists to
+     * cover.
+     */
+    trigger?: 'alertmanager' | 'case';
+    /** Required by the API on a `trigger`; ignored on resolve. */
+    summary?: string;
+    severity?: PagerDutySeverity;
+    /** Human-readable origin. Required on a `trigger`. */
+    source?: string;
+    component?: string;
+    /**
+     * PagerDuty's grouping dimension. We put the ORG ID here and nothing else —
+     * see the note on `customDetails`.
+     */
+    group?: string;
+    class?: string;
+    /**
+     * Free-form detail. IDS AND TIMESTAMPS ONLY — never case content.
+     *
+     * This is an authorization boundary, not a style preference. The on-call
+     * permission is system-org scoped and grants no tenant access at all
+     * (`isSystemOrgId` is a content-owner check, not a privilege gate), so putting
+     * a case subject or body here would route tenant content to a third party
+     * through a channel that deliberately has no right to read it.
+     */
+    customDetails?: Record<string, string | number | boolean | null>;
+}
+export interface PagerDutyResult {
+    ok: boolean;
+    /** HTTP status when the request completed. */
+    status?: number;
+    /** Why it failed, for the log line — never surfaced to a tenant. */
+    error?: string;
+    /** True when paging is configured off, so a caller can tell "off" from "broke". */
+    skipped?: boolean;
+}
+/**
+ * Which provider the Events v2 calls go to.
+ *
+ * `pagerduty` pins the known endpoint. `custom` means "something else that
+ * implements this wire format" and REQUIRES `ONCALL_EVENTS_URL` — it does not
+ * fall back, because falling back is how a typo'd URL quietly pages the wrong
+ * account, or pages nobody while reporting success.
+ *
+ * WHY THERE IS NO `opsgenie` HERE, although the design notes proposed one:
+ * nothing documents Opsgenie accepting the Events v2 shape. Its own alert API
+ * takes `message`/`alias`/`priority`, not `summary`/`severity`/`dedup_key`, so
+ * an `opsgenie` value would name a provider this client cannot actually talk to
+ * — a config option that fails at 3am on the one call that had to work. A
+ * genuinely Events-v2-compatible vendor is reachable through `custom` with its
+ * endpoint stated, which is honest about who verified the compatibility.
+ */
+export type OnCallProvider = 'pagerduty' | 'custom';
+export declare const PAGERDUTY_EVENTS_URL = "https://events.pagerduty.com/v2/enqueue";
+export interface PagerDutyConfig {
+    /**
+     * Whether paging runs at all. OPT-IN, against this repo's usual opt-out grain
+     * (`SUPPORT_ENABLED`, `BILLING_DISCOUNTS_ENABLED`): a feature needing an
+     * external credential defaults off here, the way `BILLING_METERING_ENABLED`
+     * does, and a pager with no routing key would page nobody while reporting
+     * success.
+     */
+    enabled: boolean;
+    /** Per-SERVICE integration key. NOT a REST API key — see docs/oncall-paging.md. */
+    routingKey: string;
+    provider: OnCallProvider;
+    /** Resolved from `provider` + `ONCALL_EVENTS_URL`. Empty means misconfigured. */
+    endpoint: string;
+    timeoutMs: number;
+}
+/**
+ * Resolve the endpoint from the provider and the override.
+ *
+ * Exported because the resolution has a failure case worth testing directly:
+ * `custom` with no URL returns EMPTY, and the caller treats that as
+ * unconfigured rather than silently reaching for PagerDuty's endpoint with
+ * somebody else's routing key.
+ */
+export declare function resolveEventsEndpoint(provider: OnCallProvider, override: string): string;
+export declare function pagerDutyConfig(): PagerDutyConfig;
+/**
+ * Send one event. Returns `{ ok: true }` only when PagerDuty ACCEPTED it.
+ *
+ * A 202 is an acceptance and not a delivery receipt — it says PagerDuty has the
+ * event, nothing about whether a phone rang. `oncall_pages_total{outcome}`
+ * records what we know, which is this and no more; the only honest evidence of
+ * coverage is a human acknowledging.
+ */
+export declare function sendPagerDutyEvent(event: PagerDutyEvent, cfg?: PagerDutyConfig): Promise<PagerDutyResult>;

package/lib/services/pagerduty.js

@@ -0,0 +1,186 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * PagerDuty Events API v2 — the only thing in this repo that can wake a human.
+ *
+ * WHY THIS EXISTS. `SUPPORT_PREMIUM_ENABLED` ships on, and premium sells a first
+ * response "within 8 hours, any day" — the one response target in
+ * `SUPPORT_RESPONSE_TARGETS` with no business-hours exemption, so its clock runs
+ * through nights and weekends. Before this, the only thing watching it was
+ * `SupportPremiumFirstResponseAtRisk` routed to a Slack channel, which satisfies
+ * the routing and not the obligation: the alert's own description says "if no
+ * rota is awake, that is the cause".
+ *
+ * WHY NO SDK. The whole protocol is one HTTPS POST of JSON to a fixed endpoint.
+ * An SDK for that is a dependency for nothing in a repo that digest-pins,
+ * OSV-scans and enforces `minimumReleaseAge`.
+ *
+ * WHAT THE PROVIDER OWNS, AND WHY THAT DECIDED THE DESIGN. `dedupKey` plus
+ * `event_action` means PagerDuty holds the incident state, so three things this
+ * repo would otherwise have had to build are simply theirs:
+ *
+ *  - DEDUPLICATION. Fifty premium cases breaching together — the normal shape
+ *    after any outage — is one incident, not fifty pages. Fifty pages and no
+ *    pages are the same thing.
+ *  - RESOLUTION. `resolve` on the same key closes it, so a case that finally
+ *    gets a first response stops paging without a local state machine.
+ *  - CONTACT METHODS and their verification, the rota, and escalation.
+ *
+ * So there is no rota in this codebase on purpose. What stays here is the
+ * TRIGGER, because the product knows something PagerDuty cannot: a support case
+ * carries an exact `response_due_at`, which beats a p90 histogram that can only
+ * say the distribution already drifted.
+ *
+ * NEVER THROWS. Every caller is on an alerting path — a webhook handler or a
+ * sweep — and an exception there turns "could not page" into "crashed instead of
+ * paging". Failures come back as a typed result and are counted.
+ */
+import { envBool, envInt, envStr } from '../utils/env.js';
+import { createLogger } from '../utils/logger.js';
+import { emitCounter } from '../utils/metric-emitter.js';
+import { errorMessage } from '../utils/response.js';
+import { safeFetch } from '../utils/ssrf.js';
+const logger = createLogger('pagerduty');
+export const PAGERDUTY_EVENTS_URL = 'https://events.pagerduty.com/v2/enqueue';
+/**
+ * Resolve the endpoint from the provider and the override.
+ *
+ * Exported because the resolution has a failure case worth testing directly:
+ * `custom` with no URL returns EMPTY, and the caller treats that as
+ * unconfigured rather than silently reaching for PagerDuty's endpoint with
+ * somebody else's routing key.
+ */
+export function resolveEventsEndpoint(provider, override) {
+    if (override)
+        return override;
+    return provider === 'pagerduty' ? PAGERDUTY_EVENTS_URL : '';
+}
+/**
+ * Whether paging is BOTH asked for and coherent.
+ *
+ * ON-CALL REQUIRES SUPPORT. `ONCALL_ENABLED` exists to page about a support
+ * response target, so with `SUPPORT_ENABLED=false` there is no product to page
+ * about — the bundles are inactive, no case can be opened, and the only thing
+ * left is a deployment paying per seat for a pager wired to nothing.
+ *
+ * VALIDATED FOR THE ACTIVE FEATURE ONLY, which is the precedent that matters
+ * here: a bundle validator once crashed billing at boot by checking every
+ * bundle rather than every ACTIVE one. So this neither throws nor warns when
+ * paging is off — it is not a conflict until somebody asks for the thing. When
+ * they do, the prerequisite is reported once and paging stays off rather than
+ * half-on, because a pager that fires for a product nobody sells is the same
+ * failure as a pager with no key: it reports coverage of nothing.
+ */
+function onCallCoherentlyEnabled() {
+    if (!envBool('ONCALL_ENABLED', false))
+        return false;
+    if (envBool('SUPPORT_ENABLED', true))
+        return true;
+    logger.error('ONCALL_ENABLED=true with SUPPORT_ENABLED=false — paging stays OFF', {
+        why: 'on-call pages about a support response target; with support off there are no cases and no target',
+    });
+    return false;
+}
+export function pagerDutyConfig() {
+    const provider = envStr('ONCALL_PROVIDER', 'pagerduty') === 'custom' ? 'custom' : 'pagerduty';
+    return {
+        enabled: onCallCoherentlyEnabled(),
+        // Read from the environment rather than a mounted file: unlike the
+        // Alertmanager Slack URLs (api_url_file), this key is consumed by OUR
+        // process, which already receives its secrets as env from a Secret.
+        routingKey: envStr('PAGERDUTY_ROUTING_KEY', ''),
+        provider,
+        endpoint: resolveEventsEndpoint(provider, envStr('ONCALL_EVENTS_URL', '')),
+        timeoutMs: envInt('ONCALL_EVENTS_TIMEOUT_MS', 5000, { min: 1 }),
+    };
+}
+/**
+ * Send one event. Returns `{ ok: true }` only when PagerDuty ACCEPTED it.
+ *
+ * A 202 is an acceptance and not a delivery receipt — it says PagerDuty has the
+ * event, nothing about whether a phone rang. `oncall_pages_total{outcome}`
+ * records what we know, which is this and no more; the only honest evidence of
+ * coverage is a human acknowledging.
+ */
+export async function sendPagerDutyEvent(event, cfg = pagerDutyConfig()) {
+    const labels = { action: event.action, trigger: event.trigger ?? 'alertmanager' };
+    // Configured OFF is a SKIP, distinct from a failure. The Alertmanager leg
+    // relies on this: its route is always present (alertmanager.yml is asserted
+    // byte-identical across targets, so it cannot be toggled per deployment), and
+    // this endpoint accepting-and-dropping is what makes the knob work without a
+    // second config file and without a stream of notification failures.
+    if (!cfg.enabled) {
+        emitCounter('oncall_pages_total', { ...labels, outcome: 'disabled' });
+        return { ok: true, skipped: true };
+    }
+    if (!cfg.endpoint) {
+        // `ONCALL_PROVIDER=custom` with no `ONCALL_EVENTS_URL`. Counted under the
+        // same outcome as a missing key because it is the same class of failure —
+        // somebody asked for paging and the client has nowhere to send it — and
+        // because quietly reaching for PagerDuty's endpoint instead would send this
+        // deployment's routing key to a provider nobody chose.
+        emitCounter('oncall_pages_total', { ...labels, outcome: 'unconfigured' });
+        logger.error('ONCALL_PROVIDER=custom but ONCALL_EVENTS_URL is empty — nobody will be paged', {
+            dedupKey: event.dedupKey,
+        });
+        return { ok: false, error: 'no events endpoint' };
+    }
+    if (!cfg.routingKey) {
+        // Enabled with no key is the half-configured state the knob exists to
+        // prevent, and it is the one failure worth shouting about: somebody asked
+        // for paging and is not getting it.
+        emitCounter('oncall_pages_total', { ...labels, outcome: 'unconfigured' });
+        logger.error('ONCALL_ENABLED is true but PAGERDUTY_ROUTING_KEY is empty — nobody will be paged', {
+            dedupKey: event.dedupKey,
+        });
+        return { ok: false, error: 'no routing key' };
+    }
+    // `resolve` and `acknowledge` need only the key and the action; a trigger
+    // needs summary/severity/source. Built conditionally so a resolve cannot be
+    // rejected for a missing field it never required.
+    const body = {
+        routing_key: cfg.routingKey,
+        event_action: event.action,
+        dedup_key: event.dedupKey,
+    };
+    if (event.action === 'trigger') {
+        body.payload = {
+            summary: event.summary ?? 'Pipeline Builder alert',
+            severity: event.severity ?? 'critical',
+            source: event.source ?? 'pipeline-builder',
+            ...(event.component ? { component: event.component } : {}),
+            ...(event.group ? { group: event.group } : {}),
+            ...(event.class ? { class: event.class } : {}),
+            ...(event.customDetails ? { custom_details: event.customDetails } : {}),
+        };
+    }
+    try {
+        const resp = await safeFetch(cfg.endpoint, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+            timeoutMs: cfg.timeoutMs,
+        });
+        // `safeFetch` refuses redirects rather than following them, so a 3xx arrives
+        // as `redirected` and is a FAILED send — never a pivot to an unvetted host
+        // and never recorded green.
+        if (resp.redirected) {
+            emitCounter('oncall_pages_total', { ...labels, outcome: 'redirected' });
+            logger.error('PagerDuty endpoint redirected — refused', { status: resp.status });
+            return { ok: false, status: resp.status, error: 'endpoint redirected (refused)' };
+        }
+        if (!resp.ok) {
+            emitCounter('oncall_pages_total', { ...labels, outcome: 'rejected' });
+            logger.error('PagerDuty rejected an event', { status: resp.status, dedupKey: event.dedupKey });
+            return { ok: false, status: resp.status, error: `status ${resp.status}` };
+        }
+        emitCounter('oncall_pages_total', { ...labels, outcome: 'accepted' });
+        return { ok: true, status: resp.status };
+    }
+    catch (err) {
+        emitCounter('oncall_pages_total', { ...labels, outcome: 'error' });
+        logger.error('Could not reach PagerDuty', { error: errorMessage(err), dedupKey: event.dedupKey });
+        return { ok: false, error: errorMessage(err) };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagerduty.js","sourceRoot":"","sources":["../../src/services/pagerduty.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * PagerDuty Events API v2 — the only thing in this repo that can wake a human.\n *\n * WHY THIS EXISTS. `SUPPORT_PREMIUM_ENABLED` ships on, and premium sells a first\n * response \"within 8 hours, any day\" — the one response target in\n * `SUPPORT_RESPONSE_TARGETS` with no business-hours exemption, so its clock runs\n * through nights and weekends. Before this, the only thing watching it was\n * `SupportPremiumFirstResponseAtRisk` routed to a Slack channel, which satisfies\n * the routing and not the obligation: the alert's own description says \"if no\n * rota is awake, that is the cause\".\n *\n * WHY NO SDK. The whole protocol is one HTTPS POST of JSON to a fixed endpoint.\n * An SDK for that is a dependency for nothing in a repo that digest-pins,\n * OSV-scans and enforces `minimumReleaseAge`.\n *\n * WHAT THE PROVIDER OWNS, AND WHY THAT DECIDED THE DESIGN. `dedupKey` plus\n * `event_action` means PagerDuty holds the incident state, so three things this\n * repo would otherwise have had to build are simply theirs:\n *\n *  - DEDUPLICATION. Fifty premium cases breaching together — the normal shape\n *    after any outage — is one incident, not fifty pages. Fifty pages and no\n *    pages are the same thing.\n *  - RESOLUTION. `resolve` on the same key closes it, so a case that finally\n *    gets a first response stops paging without a local state machine.\n *  - CONTACT METHODS and their verification, the rota, and escalation.\n *\n * So there is no rota in this codebase on purpose. What stays here is the\n * TRIGGER, because the product knows something PagerDuty cannot: a support case\n * carries an exact `response_due_at`, which beats a p90 histogram that can only\n * say the distribution already drifted.\n *\n * NEVER THROWS. Every caller is on an alerting path — a webhook handler or a\n * sweep — and an exception there turns \"could not page\" into \"crashed instead of\n * paging\". Failures come back as a typed result and are counted.\n */\n\nimport { envBool, envInt, envStr } from '../utils/env.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { errorMessage } from '../utils/response.js';\nimport { safeFetch } from '../utils/ssrf.js';\n\nconst logger = createLogger('pagerduty');\n\n/** PagerDuty's own severity enum. Ours map straight onto it. */\nexport type PagerDutySeverity = 'critical' | 'error' | 'warning' | 'info';\n\n/** The three follow-up actions a single `dedupKey` moves through. */\nexport type PagerDutyAction = 'trigger' | 'acknowledge' | 'resolve';\n\nexport interface PagerDutyEvent {\n  /**\n   * The key that ties a trigger to its later acknowledge/resolve. Stable and\n   * derived, never random: `case:<caseId>` for the per-case sweep,\n   * Alertmanager's own group fingerprint for the alert leg — so its grouping and\n   * ours cannot fight over the same incident.\n   */\n  dedupKey: string;\n  action: PagerDutyAction;\n  /**\n   * WHICH leg raised this, as a metric dimension only — never sent to PagerDuty.\n   *\n   * The two legs have different failure modes and must be separable in one\n   * counter: `alertmanager` depends on Prometheus evaluating and Alertmanager\n   * delivering, `case` depends on this product's own sweep being alive. Collapsed\n   * into one series, a dead sweep is invisible for as long as the fleet alert\n   * still fires — which is precisely the window the per-case trigger exists to\n   * cover.\n   */\n  trigger?: 'alertmanager' | 'case';\n  /** Required by the API on a `trigger`; ignored on resolve. */\n  summary?: string;\n  severity?: PagerDutySeverity;\n  /** Human-readable origin. Required on a `trigger`. */\n  source?: string;\n  component?: string;\n  /**\n   * PagerDuty's grouping dimension. We put the ORG ID here and nothing else —\n   * see the note on `customDetails`.\n   */\n  group?: string;\n  class?: string;\n  /**\n   * Free-form detail. IDS AND TIMESTAMPS ONLY — never case content.\n   *\n   * This is an authorization boundary, not a style preference. The on-call\n   * permission is system-org scoped and grants no tenant access at all\n   * (`isSystemOrgId` is a content-owner check, not a privilege gate), so putting\n   * a case subject or body here would route tenant content to a third party\n   * through a channel that deliberately has no right to read it.\n   */\n  customDetails?: Record<string, string | number | boolean | null>;\n}\n\nexport interface PagerDutyResult {\n  ok: boolean;\n  /** HTTP status when the request completed. */\n  status?: number;\n  /** Why it failed, for the log line — never surfaced to a tenant. */\n  error?: string;\n  /** True when paging is configured off, so a caller can tell \"off\" from \"broke\". */\n  skipped?: boolean;\n}\n\n/**\n * Which provider the Events v2 calls go to.\n *\n * `pagerduty` pins the known endpoint. `custom` means \"something else that\n * implements this wire format\" and REQUIRES `ONCALL_EVENTS_URL` — it does not\n * fall back, because falling back is how a typo'd URL quietly pages the wrong\n * account, or pages nobody while reporting success.\n *\n * WHY THERE IS NO `opsgenie` HERE, although the design notes proposed one:\n * nothing documents Opsgenie accepting the Events v2 shape. Its own alert API\n * takes `message`/`alias`/`priority`, not `summary`/`severity`/`dedup_key`, so\n * an `opsgenie` value would name a provider this client cannot actually talk to\n * — a config option that fails at 3am on the one call that had to work. A\n * genuinely Events-v2-compatible vendor is reachable through `custom` with its\n * endpoint stated, which is honest about who verified the compatibility.\n */\nexport type OnCallProvider = 'pagerduty' | 'custom';\n\nexport const PAGERDUTY_EVENTS_URL = 'https://events.pagerduty.com/v2/enqueue';\n\nexport interface PagerDutyConfig {\n  /**\n   * Whether paging runs at all. OPT-IN, against this repo's usual opt-out grain\n   * (`SUPPORT_ENABLED`, `BILLING_DISCOUNTS_ENABLED`): a feature needing an\n   * external credential defaults off here, the way `BILLING_METERING_ENABLED`\n   * does, and a pager with no routing key would page nobody while reporting\n   * success.\n   */\n  enabled: boolean;\n  /** Per-SERVICE integration key. NOT a REST API key — see docs/oncall-paging.md. */\n  routingKey: string;\n  provider: OnCallProvider;\n  /** Resolved from `provider` + `ONCALL_EVENTS_URL`. Empty means misconfigured. */\n  endpoint: string;\n  timeoutMs: number;\n}\n\n/**\n * Resolve the endpoint from the provider and the override.\n *\n * Exported because the resolution has a failure case worth testing directly:\n * `custom` with no URL returns EMPTY, and the caller treats that as\n * unconfigured rather than silently reaching for PagerDuty's endpoint with\n * somebody else's routing key.\n */\nexport function resolveEventsEndpoint(provider: OnCallProvider, override: string): string {\n  if (override) return override;\n  return provider === 'pagerduty' ? PAGERDUTY_EVENTS_URL : '';\n}\n\n/**\n * Whether paging is BOTH asked for and coherent.\n *\n * ON-CALL REQUIRES SUPPORT. `ONCALL_ENABLED` exists to page about a support\n * response target, so with `SUPPORT_ENABLED=false` there is no product to page\n * about — the bundles are inactive, no case can be opened, and the only thing\n * left is a deployment paying per seat for a pager wired to nothing.\n *\n * VALIDATED FOR THE ACTIVE FEATURE ONLY, which is the precedent that matters\n * here: a bundle validator once crashed billing at boot by checking every\n * bundle rather than every ACTIVE one. So this neither throws nor warns when\n * paging is off — it is not a conflict until somebody asks for the thing. When\n * they do, the prerequisite is reported once and paging stays off rather than\n * half-on, because a pager that fires for a product nobody sells is the same\n * failure as a pager with no key: it reports coverage of nothing.\n */\nfunction onCallCoherentlyEnabled(): boolean {\n  if (!envBool('ONCALL_ENABLED', false)) return false;\n  if (envBool('SUPPORT_ENABLED', true)) return true;\n  logger.error('ONCALL_ENABLED=true with SUPPORT_ENABLED=false — paging stays OFF', {\n    why: 'on-call pages about a support response target; with support off there are no cases and no target',\n  });\n  return false;\n}\n\nexport function pagerDutyConfig(): PagerDutyConfig {\n  const provider = envStr('ONCALL_PROVIDER', 'pagerduty') === 'custom' ? 'custom' : 'pagerduty';\n  return {\n    enabled: onCallCoherentlyEnabled(),\n    // Read from the environment rather than a mounted file: unlike the\n    // Alertmanager Slack URLs (api_url_file), this key is consumed by OUR\n    // process, which already receives its secrets as env from a Secret.\n    routingKey: envStr('PAGERDUTY_ROUTING_KEY', ''),\n    provider,\n    endpoint: resolveEventsEndpoint(provider, envStr('ONCALL_EVENTS_URL', '')),\n    timeoutMs: envInt('ONCALL_EVENTS_TIMEOUT_MS', 5000, { min: 1 }),\n  };\n}\n\n/**\n * Send one event. Returns `{ ok: true }` only when PagerDuty ACCEPTED it.\n *\n * A 202 is an acceptance and not a delivery receipt — it says PagerDuty has the\n * event, nothing about whether a phone rang. `oncall_pages_total{outcome}`\n * records what we know, which is this and no more; the only honest evidence of\n * coverage is a human acknowledging.\n */\nexport async function sendPagerDutyEvent(\n  event: PagerDutyEvent,\n  cfg: PagerDutyConfig = pagerDutyConfig(),\n): Promise<PagerDutyResult> {\n  const labels = { action: event.action, trigger: event.trigger ?? 'alertmanager' };\n\n  // Configured OFF is a SKIP, distinct from a failure. The Alertmanager leg\n  // relies on this: its route is always present (alertmanager.yml is asserted\n  // byte-identical across targets, so it cannot be toggled per deployment), and\n  // this endpoint accepting-and-dropping is what makes the knob work without a\n  // second config file and without a stream of notification failures.\n  if (!cfg.enabled) {\n    emitCounter('oncall_pages_total', { ...labels, outcome: 'disabled' });\n    return { ok: true, skipped: true };\n  }\n  if (!cfg.endpoint) {\n    // `ONCALL_PROVIDER=custom` with no `ONCALL_EVENTS_URL`. Counted under the\n    // same outcome as a missing key because it is the same class of failure —\n    // somebody asked for paging and the client has nowhere to send it — and\n    // because quietly reaching for PagerDuty's endpoint instead would send this\n    // deployment's routing key to a provider nobody chose.\n    emitCounter('oncall_pages_total', { ...labels, outcome: 'unconfigured' });\n    logger.error('ONCALL_PROVIDER=custom but ONCALL_EVENTS_URL is empty — nobody will be paged', {\n      dedupKey: event.dedupKey,\n    });\n    return { ok: false, error: 'no events endpoint' };\n  }\n  if (!cfg.routingKey) {\n    // Enabled with no key is the half-configured state the knob exists to\n    // prevent, and it is the one failure worth shouting about: somebody asked\n    // for paging and is not getting it.\n    emitCounter('oncall_pages_total', { ...labels, outcome: 'unconfigured' });\n    logger.error('ONCALL_ENABLED is true but PAGERDUTY_ROUTING_KEY is empty — nobody will be paged', {\n      dedupKey: event.dedupKey,\n    });\n    return { ok: false, error: 'no routing key' };\n  }\n\n  // `resolve` and `acknowledge` need only the key and the action; a trigger\n  // needs summary/severity/source. Built conditionally so a resolve cannot be\n  // rejected for a missing field it never required.\n  const body: Record<string, unknown> = {\n    routing_key: cfg.routingKey,\n    event_action: event.action,\n    dedup_key: event.dedupKey,\n  };\n  if (event.action === 'trigger') {\n    body.payload = {\n      summary: event.summary ?? 'Pipeline Builder alert',\n      severity: event.severity ?? 'critical',\n      source: event.source ?? 'pipeline-builder',\n      ...(event.component ? { component: event.component } : {}),\n      ...(event.group ? { group: event.group } : {}),\n      ...(event.class ? { class: event.class } : {}),\n      ...(event.customDetails ? { custom_details: event.customDetails } : {}),\n    };\n  }\n\n  try {\n    const resp = await safeFetch(cfg.endpoint, {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/json' },\n      body: JSON.stringify(body),\n      timeoutMs: cfg.timeoutMs,\n    });\n    // `safeFetch` refuses redirects rather than following them, so a 3xx arrives\n    // as `redirected` and is a FAILED send — never a pivot to an unvetted host\n    // and never recorded green.\n    if (resp.redirected) {\n      emitCounter('oncall_pages_total', { ...labels, outcome: 'redirected' });\n      logger.error('PagerDuty endpoint redirected — refused', { status: resp.status });\n      return { ok: false, status: resp.status, error: 'endpoint redirected (refused)' };\n    }\n    if (!resp.ok) {\n      emitCounter('oncall_pages_total', { ...labels, outcome: 'rejected' });\n      logger.error('PagerDuty rejected an event', { status: resp.status, dedupKey: event.dedupKey });\n      return { ok: false, status: resp.status, error: `status ${resp.status}` };\n    }\n    emitCounter('oncall_pages_total', { ...labels, outcome: 'accepted' });\n    return { ok: true, status: resp.status };\n  } catch (err) {\n    emitCounter('oncall_pages_total', { ...labels, outcome: 'error' });\n    logger.error('Could not reach PagerDuty', { error: errorMessage(err), dedupKey: event.dedupKey });\n    return { ok: false, error: errorMessage(err) };\n  }\n}\n"]}