@cursor/bdk 0.2.24 → 0.2.25

package/dist/channels/pagerduty/pagerduty-webhook.js

@@ -0,0 +1,280 @@
+import { createHmac } from "node:crypto";
+import { acknowledgeTask, isTaskDispatch, skipped, turnStarted, } from "../../internal/channel-dispatch.js";
+import { continuationSource, mintClaim } from "../../internal/continuation-identity.js";
+import { hmacSignatureMatchesAny, parseHmacSecrets } from "../../internal/hmac-secret-values.js";
+import { bindLocalIngressSend } from "../../internal/local-ingress.js";
+import { defaultPagerDutyIncidentDispatch, defaultPagerDutyIncidentMessage, defaultPagerDutyTitle, } from "./defaults.js";
+import { isPagerDutyIncidentLifecycleEvent, PAGERDUTY_CHANNEL_KIND, PAGERDUTY_NOTE_EVENTS, PAGERDUTY_RESPONDER_EVENTS, } from "./events.js";
+import { asNonEmptyString, pagerDutyAccountSubdomain, pagerDutyEventIncident, pagerDutyEventRecord, pagerDutyIncidentFromData, pagerDutyNoteFromData, pagerDutyReference, pagerDutyResponderFromData, } from "./payload.js";
+import { pagerDutyChannelClient } from "./api.js";
+import { resolvePagerDutySecret } from "./secrets.js";
+import { resolvePagerDutySelfUserIds } from "./self-user.js";
+import { pagerDutyChannelStateForEvent } from "./state.js";
+/** Env var / deployment secret an omitted `webhookSecret` falls back to. */
+export const PAGERDUTY_WEBHOOK_SECRET_ENV = "PAGERDUTY_WEBHOOK_SECRET";
+/** Header PagerDuty signs v3 deliveries with: `v1=<hex>[,v1=<hex>…]`. */
+export const PAGERDUTY_SIGNATURE_HEADER = "x-pagerduty-signature";
+export const PAGERDUTY_SIGNATURE_PREFIX = "v1=";
+/** Separator between signatures while a subscription's secret rotates. */
+export const PAGERDUTY_SIGNATURE_SEPARATOR = ",";
+/**
+ * The secret's value for the handler's own signature check, read now: an
+ * omitted field names `PAGERDUTY_WEBHOOK_SECRET` (hosted, the addressed
+ * installation's secret), and an authored name never falls back to it.
+ */
+export function resolvePagerDutyWebhookSecret(options) {
+    return resolvePagerDutySecret(options.webhookSecret, PAGERDUTY_WEBHOOK_SECRET_ENV);
+}
+/** One `X-PagerDuty-Signature` entry for a raw body: `v1=<hex>`. */
+export function signPagerDutyWebhookBody(input) {
+    return `${PAGERDUTY_SIGNATURE_PREFIX}${createHmac("sha256", input.secret).update(input.rawBody).digest("hex")}`;
+}
+/**
+ * True when any `v1=` entry in the header is the body's HMAC-SHA256 under
+ * any secret `secret` holds. `secret` is the named secret's value: one
+ * signing secret, or one per line when several subscriptions sign the
+ * route. Every (secret, entry) pair is compared in constant time with no
+ * early exit; malformed entries never match, and a missing header is a
+ * plain `false`.
+ */
+export function verifyPagerDutyWebhookSignature(input) {
+    const parsed = parseHmacSecrets(input.secret);
+    if (input.signatureHeader === null || input.signatureHeader === undefined || !parsed.ok) {
+        return false;
+    }
+    return hmacSignatureMatchesAny({
+        body: input.rawBody,
+        presented: input.signatureHeader,
+        secrets: parsed.secrets,
+        prefix: PAGERDUTY_SIGNATURE_PREFIX,
+        separator: PAGERDUTY_SIGNATURE_SEPARATOR,
+    });
+}
+/**
+ * True when the event is the agent's own action echoed back: its `agent`
+ * is a PagerDuty user the agent acts as. Service integrations and
+ * PagerDuty itself never count, so an alert the agent's own monitor opened
+ * still dispatches.
+ */
+export function isPagerDutySelfEcho(ctx, selfUserIds) {
+    const agent = ctx.agent;
+    if (agent === undefined || selfUserIds.size === 0) {
+        return false;
+    }
+    if (agent.type !== undefined && agent.type !== "user_reference" && agent.type !== "user") {
+        return false;
+    }
+    return selfUserIds.has(agent.id);
+}
+/**
+ * Accept a raw v3 body. The event type comes from the signed body's
+ * `event.event_type`, never from a header, so a captured delivery cannot be
+ * re-dispatched as another event.
+ */
+export function parsePagerDutyWebhookPayload(payload) {
+    const event = pagerDutyEventRecord(payload);
+    const eventType = asNonEmptyString(event?.event_type);
+    if (event === undefined || eventType === undefined) {
+        return null;
+    }
+    return { eventType, payload: payload };
+}
+export function parsePagerDutyEventContext(delivery) {
+    const event = pagerDutyEventRecord(delivery.payload);
+    const eventId = asNonEmptyString(event?.id);
+    if (event === undefined || eventId === undefined) {
+        return null;
+    }
+    const incident = pagerDutyEventIncident(event);
+    return {
+        deliveryId: delivery.deliveryId,
+        eventId,
+        eventType: delivery.eventType,
+        resourceType: asNonEmptyString(event.resource_type),
+        occurredAt: asNonEmptyString(event.occurred_at),
+        agent: pagerDutyReference(event.agent),
+        incidentId: incident?.id,
+        incidentKey: incident?.incidentKey,
+        accountSubdomain: pagerDutyAccountSubdomain(event),
+        payload: event,
+    };
+}
+function invalidPayload(error) {
+    return Response.json({ ok: false, error }, { status: 400 });
+}
+async function applyDispatch(input) {
+    const extra = { event: input.ctx.eventType };
+    if (input.dispatch === null) {
+        return skipped("not_dispatched", extra);
+    }
+    if (isTaskDispatch(input.dispatch)) {
+        return acknowledgeTask(input.args, PAGERDUTY_CHANNEL_KIND, input.dispatch, extra);
+    }
+    const ctx = input.ctx;
+    const state = pagerDutyChannelStateForEvent({
+        eventType: ctx.eventType,
+        eventId: ctx.eventId,
+        incidentId: ctx.incidentId,
+        incidentNumber: input.incidentNumber,
+        incidentKey: ctx.incidentKey,
+        serviceId: input.serviceId,
+        deliveryId: ctx.deliveryId,
+        occurredAt: ctx.occurredAt,
+    });
+    // v1 agents (omitted continuation resolves to `none/v1`) keep one
+    // engine-minted conversation per incident; v2 takes the CP stamp.
+    const engineToken = continuationSource(input.options.continuation, PAGERDUTY_CHANNEL_KIND) === "engine" &&
+        ctx.incidentId !== undefined
+        ? mintClaim({
+            type: "pagerduty-incident",
+            resource: { incidentId: ctx.incidentId },
+        }).slice("cont:".length)
+        : undefined;
+    const turn = {
+        auth: input.dispatch.auth,
+        title: input.dispatch.title ?? input.title,
+        state: state,
+        refreshState: state,
+    };
+    if (engineToken !== undefined) {
+        turn.continuationToken = engineToken;
+    }
+    if (input.options.cloud !== undefined) {
+        turn.cloud = input.options.cloud;
+    }
+    const session = await input.args.send([input.dispatch.message ?? input.message, ...(input.dispatch.context ?? [])].join("\n"), turn);
+    return turnStarted(session);
+}
+/**
+ * Run the authored hooks for one verified PagerDuty delivery and `send()`
+ * the turn. Callers own delivery auth: the HTTP route verifies
+ * `X-PagerDuty-Signature`; hosted admission arrives verified. The v2
+ * mailbox is stamped upstream (local CP or hosted ingress), never here.
+ */
+export async function dispatchPagerDutyWebhook(input) {
+    const parsed = parsePagerDutyEventContext(input.delivery);
+    if (parsed === null) {
+        return invalidPayload("invalid_pagerduty_payload");
+    }
+    const args = input.args;
+    const ctx = {
+        ...parsed,
+        pagerduty: pagerDutyChannelClient(input.options),
+        host: args.host,
+        artifacts: args.artifacts,
+        send: args.send,
+    };
+    const eventType = ctx.eventType;
+    if (eventType === "pagey.ping") {
+        return skipped("ping");
+    }
+    if (isPagerDutySelfEcho(ctx, await resolvePagerDutySelfUserIds({ options: input.options }))) {
+        return skipped("self_echo", { event: eventType, agent: ctx.agent?.id });
+    }
+    const data = ctx.payload.data;
+    if (isPagerDutyIncidentLifecycleEvent(eventType)) {
+        const incident = pagerDutyIncidentFromData(data);
+        if (incident === undefined) {
+            return invalidPayload("invalid_pagerduty_incident_payload");
+        }
+        const event = { eventType, action: eventType.slice("incident.".length), incident };
+        const dispatch = input.options.onIncident === undefined
+            ? defaultPagerDutyIncidentDispatch(ctx, event)
+            : await input.options.onIncident(ctx, event);
+        return applyDispatch({
+            options: input.options,
+            args,
+            ctx,
+            dispatch,
+            message: defaultPagerDutyIncidentMessage(ctx, event),
+            title: defaultPagerDutyTitle(ctx, incident),
+            incidentNumber: incident.number,
+            serviceId: incident.service?.id,
+        });
+    }
+    if (PAGERDUTY_NOTE_EVENTS.includes(eventType)) {
+        if (input.options.onNote === undefined) {
+            return skipped("no_handler", { event: eventType });
+        }
+        const note = pagerDutyNoteFromData(data);
+        if (note === undefined) {
+            return invalidPayload("invalid_pagerduty_note_payload");
+        }
+        return applyDispatch({
+            options: input.options,
+            args,
+            ctx,
+            dispatch: await input.options.onNote(ctx, note),
+            message: `PagerDuty note on incident ${note.incident.id}:\n${note.content}`,
+            title: defaultPagerDutyTitle(ctx),
+        });
+    }
+    if (PAGERDUTY_RESPONDER_EVENTS.includes(eventType)) {
+        if (input.options.onResponder === undefined) {
+            return skipped("no_handler", { event: eventType });
+        }
+        const responder = pagerDutyResponderFromData(eventType, data);
+        if (responder === undefined) {
+            return invalidPayload("invalid_pagerduty_responder_payload");
+        }
+        return applyDispatch({
+            options: input.options,
+            args,
+            ctx,
+            dispatch: await input.options.onResponder(ctx, responder),
+            message: `PagerDuty ${eventType} on incident ${responder.incident.id}`,
+            title: defaultPagerDutyTitle(ctx),
+        });
+    }
+    if (input.options.onEvent === undefined) {
+        return skipped("unsupported_event", { event: eventType });
+    }
+    return applyDispatch({
+        options: input.options,
+        args,
+        ctx,
+        dispatch: await input.options.onEvent(ctx, { eventType, data }),
+        message: `PagerDuty ${eventType} event`,
+        title: defaultPagerDutyTitle(ctx),
+    });
+}
+/**
+ * HTTP entry for one agent's PagerDuty channel: the `X-PagerDuty-Signature`
+ * check when a secret is configured, then {@link dispatchPagerDutyWebhook}.
+ * Without a secret the route auth owns admission (`serve --dev` admits
+ * loopback only; production stays loopback-strict).
+ */
+export async function handlePagerDutyWebhookRequest(input) {
+    const bodyText = await input.request.text();
+    const secret = resolvePagerDutyWebhookSecret(input.options);
+    if (secret !== undefined &&
+        !verifyPagerDutyWebhookSignature({
+            rawBody: bodyText,
+            signatureHeader: input.request.headers.get(PAGERDUTY_SIGNATURE_HEADER),
+            secret,
+        })) {
+        return Response.json({ ok: false, error: "invalid_signature" }, { status: 401 });
+    }
+    let payload;
+    try {
+        payload = JSON.parse(bodyText);
+    }
+    catch {
+        return Response.json({ ok: false, error: "invalid_json" }, { status: 400 });
+    }
+    const delivery = parsePagerDutyWebhookPayload(payload);
+    if (delivery === null) {
+        return invalidPayload("invalid_pagerduty_payload");
+    }
+    delivery.deliveryId = input.request.headers.get("x-webhook-id") ?? undefined;
+    return dispatchPagerDutyWebhook({
+        options: input.options,
+        delivery,
+        args: bindLocalIngressSend(input.args, {
+            identity: input.options.continuation,
+            kind: PAGERDUTY_CHANNEL_KIND,
+            eventType: delivery.eventType,
+            payload: delivery.payload,
+        }),
+    });
+}

package/dist/channels/pagerduty/payload.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Typed views over a PagerDuty v3 webhook body. Every reader tolerates
+ * missing optional fields and returns `undefined` for a shape it does not
+ * recognize, so a new PagerDuty field never fails a delivery.
+ */
+import type { PagerDutyIncident, PagerDutyIncidentNote, PagerDutyReference, PagerDutyResponderEvent } from "./types.js";
+export declare function asRecord(value: unknown): Record<string, unknown> | undefined;
+export declare function asNonEmptyString(value: unknown): string | undefined;
+/** The delivery's `event` record, or `undefined` when the body is not a v3 event. */
+export declare function pagerDutyEventRecord(payload: unknown): Record<string, unknown> | undefined;
+export declare function pagerDutyReference(value: unknown): PagerDutyReference | undefined;
+/** `data` of a lifecycle event: the full incident. */
+export declare function pagerDutyIncidentFromData(data: unknown): PagerDutyIncident | undefined;
+/** `data` of `incident.annotated`. */
+export declare function pagerDutyNoteFromData(data: unknown): PagerDutyIncidentNote | undefined;
+/** `data` of `incident.responder.added` / `.replied`. */
+export declare function pagerDutyResponderFromData(eventType: string, data: unknown): PagerDutyResponderEvent | undefined;
+/**
+ * The incident any incident event names: `data` itself for lifecycle
+ * events, `data.incident` for sub-resources. Mirrors the continuation
+ * selector, so a hook's `ctx.incidentId` names the session's incident.
+ */
+export declare function pagerDutyEventIncident(event: Record<string, unknown>): {
+    id: string;
+    incidentKey?: string;
+} | undefined;
+/**
+ * The account subdomain (`acme` for `acme.pagerduty.com` or
+ * `acme.eu.pagerduty.com`) from the first PagerDuty web URL the event
+ * carries: the incident's, the agent's, or the data's own.
+ */
+export declare function pagerDutyAccountSubdomain(event: Record<string, unknown>): string | undefined;
+//# sourceMappingURL=payload.d.ts.map

package/dist/channels/pagerduty/payload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../../../src/channels/pagerduty/payload.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,iBAAiB,EACjB,qBAAqB,EAErB,kBAAkB,EAClB,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAEpB,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAI5E;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAEnE;AAMD,qFAAqF;AACrF,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAG1F;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,kBAAkB,GAAG,SAAS,CAYjF;AAYD,sDAAsD;AACtD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,OAAO,GAAG,iBAAiB,GAAG,SAAS,CAsBtF;AAUD,sCAAsC;AACtC,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,GAAG,qBAAqB,GAAG,SAAS,CAYtF;AAED,yDAAyD;AACzD,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,OAAO,GACZ,uBAAuB,GAAG,SAAS,CAcrC;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAUlD;AAID;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,SAAS,CAuB5F"}

package/dist/channels/pagerduty/payload.js

@@ -0,0 +1,150 @@
+/**
+ * Typed views over a PagerDuty v3 webhook body. Every reader tolerates
+ * missing optional fields and returns `undefined` for a shape it does not
+ * recognize, so a new PagerDuty field never fails a delivery.
+ */
+export function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+export function asNonEmptyString(value) {
+    return typeof value === "string" && value.trim() !== "" ? value.trim() : undefined;
+}
+function asPositiveInt(value) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : undefined;
+}
+/** The delivery's `event` record, or `undefined` when the body is not a v3 event. */
+export function pagerDutyEventRecord(payload) {
+    const event = asRecord(asRecord(payload)?.event);
+    return asNonEmptyString(event?.event_type) === undefined ? undefined : event;
+}
+export function pagerDutyReference(value) {
+    const record = asRecord(value);
+    const id = asNonEmptyString(record?.id);
+    if (record === undefined || id === undefined) {
+        return undefined;
+    }
+    return {
+        id,
+        type: asNonEmptyString(record.type),
+        summary: asNonEmptyString(record.summary),
+        htmlUrl: asNonEmptyString(record.html_url),
+    };
+}
+function references(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap((entry) => {
+        const reference = pagerDutyReference(entry);
+        return reference === undefined ? [] : [reference];
+    });
+}
+/** `data` of a lifecycle event: the full incident. */
+export function pagerDutyIncidentFromData(data) {
+    const record = asRecord(data);
+    const id = asNonEmptyString(record?.id);
+    if (record === undefined || id === undefined || record.type !== "incident") {
+        return undefined;
+    }
+    return {
+        id,
+        number: asPositiveInt(record.number),
+        title: asNonEmptyString(record.title),
+        status: asNonEmptyString(record.status),
+        urgency: asNonEmptyString(record.urgency),
+        incidentKey: asNonEmptyString(record.incident_key),
+        htmlUrl: asNonEmptyString(record.html_url),
+        createdAt: asNonEmptyString(record.created_at),
+        service: pagerDutyReference(record.service),
+        escalationPolicy: pagerDutyReference(record.escalation_policy),
+        priority: pagerDutyReference(record.priority),
+        assignees: references(record.assignees),
+        teams: references(record.teams),
+        resolveReason: asNonEmptyString(record.resolve_reason),
+    };
+}
+function incidentRef(value) {
+    const reference = pagerDutyReference(value);
+    if (reference === undefined) {
+        return undefined;
+    }
+    return { ...reference, incidentKey: asNonEmptyString(asRecord(value)?.incident_key) };
+}
+/** `data` of `incident.annotated`. */
+export function pagerDutyNoteFromData(data) {
+    const record = asRecord(data);
+    const incident = incidentRef(record?.incident);
+    if (record === undefined || incident === undefined || typeof record.content !== "string") {
+        return undefined;
+    }
+    return {
+        id: asNonEmptyString(record.id),
+        content: record.content,
+        trimmed: record.trimmed === true,
+        incident,
+    };
+}
+/** `data` of `incident.responder.added` / `.replied`. */
+export function pagerDutyResponderFromData(eventType, data) {
+    const record = asRecord(data);
+    const incident = incidentRef(record?.incident);
+    if (record === undefined || incident === undefined) {
+        return undefined;
+    }
+    return {
+        action: eventType === "incident.responder.replied" ? "replied" : "added",
+        incident,
+        user: pagerDutyReference(record.user),
+        escalationPolicy: pagerDutyReference(record.escalation_policy),
+        message: asNonEmptyString(record.message),
+        state: asNonEmptyString(record.state),
+    };
+}
+/**
+ * The incident any incident event names: `data` itself for lifecycle
+ * events, `data.incident` for sub-resources. Mirrors the continuation
+ * selector, so a hook's `ctx.incidentId` names the session's incident.
+ */
+export function pagerDutyEventIncident(event) {
+    const data = asRecord(event.data);
+    const record = asRecord(data?.incident) ??
+        (data?.type === "incident" || event.resource_type === "incident" ? data : undefined);
+    const id = asNonEmptyString(record?.id);
+    if (id === undefined) {
+        return undefined;
+    }
+    return { id, incidentKey: asNonEmptyString(record?.incident_key) };
+}
+const PAGERDUTY_HOST = /^([a-z0-9][a-z0-9-]*)\.(?:[a-z]{2}\.)?pagerduty\.com$/i;
+/**
+ * The account subdomain (`acme` for `acme.pagerduty.com` or
+ * `acme.eu.pagerduty.com`) from the first PagerDuty web URL the event
+ * carries: the incident's, the agent's, or the data's own.
+ */
+export function pagerDutyAccountSubdomain(event) {
+    const data = asRecord(event.data);
+    const candidates = [
+        asRecord(data?.incident)?.html_url,
+        data?.html_url,
+        asRecord(event.agent)?.html_url,
+        asRecord(data?.service)?.html_url,
+    ];
+    for (const candidate of candidates) {
+        const url = asNonEmptyString(candidate);
+        if (url === undefined) {
+            continue;
+        }
+        try {
+            const match = PAGERDUTY_HOST.exec(new URL(url).hostname);
+            if (match?.[1] !== undefined) {
+                return match[1].toLowerCase();
+            }
+        }
+        catch {
+            // Not a URL; try the next one.
+        }
+    }
+    return undefined;
+}

package/dist/channels/pagerduty/replay.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Synthesize PagerDuty v3 webhook bodies for `bdk pagerduty replay`, so a
+ * local `pagerdutyChannel()` can be exercised without a PagerDuty account
+ * or tunnel. The bodies follow PagerDuty's documented v3 shapes: lifecycle
+ * events carry the incident as `data`, notes carry it as `data.incident`.
+ */
+/** Event types `replay` can synthesize, in the order an incident usually sees them. */
+export declare const PAGERDUTY_REPLAYABLE_EVENTS: readonly ["incident.triggered", "incident.acknowledged", "incident.annotated", "incident.escalated", "incident.resolved", "incident.reopened"];
+export type PagerDutyReplayableEvent = (typeof PAGERDUTY_REPLAYABLE_EVENTS)[number];
+export declare const PAGERDUTY_REPLAY_DEFAULT_INCIDENT_ID = "PREPLAY1";
+/**
+ * Pick the events to replay. Accepts full names (`incident.resolved`) or
+ * the action alone (`resolved`); `*` selects every declared event that can
+ * be synthesized. Defaults to `incident.triggered`.
+ */
+export declare function selectPagerDutyReplayEvents(input: {
+    /** Event names from `--events`; omitted selects the default. */
+    requested: readonly string[] | undefined;
+    /** The event types the target channels declare. */
+    declared: readonly string[];
+}): {
+    events: PagerDutyReplayableEvent[];
+    unsupported: string[];
+};
+/**
+ * One v3 delivery body for `eventType` on `incidentId`. A trigger comes
+ * from PagerDuty itself (no `agent`); every other event is a person's
+ * action, so it dispatches rather than being skipped as the agent's echo.
+ */
+export declare function synthesizePagerDutyEvent(input: {
+    eventType: PagerDutyReplayableEvent;
+    incidentId?: string;
+    note?: string;
+}): Record<string, unknown>;
+//# sourceMappingURL=replay.d.ts.map

package/dist/channels/pagerduty/replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.d.ts","sourceRoot":"","sources":["../../../src/channels/pagerduty/replay.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,uFAAuF;AACvF,eAAO,MAAM,2BAA2B,YACtC,oBAAoB,EACpB,uBAAuB,EACvB,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,mBAAmB,CACX,CAAC;AAEX,MAAM,MAAM,wBAAwB,GAAG,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC;AAWpF,eAAO,MAAM,oCAAoC,aAAa,CAAC;AAe/D;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE;IACjD,gEAAgE;IAChE,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;IACzC,mDAAmD;IACnD,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B,GAAG;IAAE,MAAM,EAAE,wBAAwB,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,CAwBhE;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE;IAC9C,SAAS,EAAE,wBAAwB,CAAC;IACpC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAyC1B"}

package/dist/channels/pagerduty/replay.js

@@ -0,0 +1,115 @@
+/**
+ * Synthesize PagerDuty v3 webhook bodies for `bdk pagerduty replay`, so a
+ * local `pagerdutyChannel()` can be exercised without a PagerDuty account
+ * or tunnel. The bodies follow PagerDuty's documented v3 shapes: lifecycle
+ * events carry the incident as `data`, notes carry it as `data.incident`.
+ */
+import { randomUUID } from "node:crypto";
+/** Event types `replay` can synthesize, in the order an incident usually sees them. */
+export const PAGERDUTY_REPLAYABLE_EVENTS = [
+    "incident.triggered",
+    "incident.acknowledged",
+    "incident.annotated",
+    "incident.escalated",
+    "incident.resolved",
+    "incident.reopened",
+];
+const STATUS_BY_EVENT = {
+    "incident.triggered": "triggered",
+    "incident.acknowledged": "acknowledged",
+    "incident.annotated": "triggered",
+    "incident.escalated": "triggered",
+    "incident.resolved": "resolved",
+    "incident.reopened": "triggered",
+};
+export const PAGERDUTY_REPLAY_DEFAULT_INCIDENT_ID = "PREPLAY1";
+const SUBDOMAIN = "example";
+const SERVICE = {
+    id: "PSVCREP",
+    type: "service_reference",
+    summary: "replayed-service",
+    html_url: `https://${SUBDOMAIN}.pagerduty.com/service-directory/PSVCREP`,
+};
+const RESPONDER = {
+    id: "PUSERREP",
+    type: "user_reference",
+    summary: "Replay Responder",
+    html_url: `https://${SUBDOMAIN}.pagerduty.com/users/PUSERREP`,
+};
+/**
+ * Pick the events to replay. Accepts full names (`incident.resolved`) or
+ * the action alone (`resolved`); `*` selects every declared event that can
+ * be synthesized. Defaults to `incident.triggered`.
+ */
+export function selectPagerDutyReplayEvents(input) {
+    const { requested, declared } = input;
+    const replayable = new Set(PAGERDUTY_REPLAYABLE_EVENTS);
+    if (requested === undefined) {
+        return { events: ["incident.triggered"], unsupported: [] };
+    }
+    if (requested.length === 1 && requested[0] === "*") {
+        const pool = declared.length === 0 ? PAGERDUTY_REPLAYABLE_EVENTS : declared;
+        return {
+            events: PAGERDUTY_REPLAYABLE_EVENTS.filter((event) => pool.includes(event)),
+            unsupported: [],
+        };
+    }
+    const events = [];
+    const unsupported = [];
+    for (const raw of requested) {
+        const name = raw.startsWith("incident.") ? raw : `incident.${raw}`;
+        if (replayable.has(name)) {
+            events.push(name);
+        }
+        else {
+            unsupported.push(raw);
+        }
+    }
+    return { events, unsupported };
+}
+/**
+ * One v3 delivery body for `eventType` on `incidentId`. A trigger comes
+ * from PagerDuty itself (no `agent`); every other event is a person's
+ * action, so it dispatches rather than being skipped as the agent's echo.
+ */
+export function synthesizePagerDutyEvent(input) {
+    const incidentId = input.incidentId ?? PAGERDUTY_REPLAY_DEFAULT_INCIDENT_ID;
+    const incidentUrl = `https://${SUBDOMAIN}.pagerduty.com/incidents/${incidentId}`;
+    const data = input.eventType === "incident.annotated"
+        ? {
+            id: `PNOTE${randomUUID().slice(0, 6).toUpperCase()}`,
+            type: "incident_note",
+            content: input.note ?? "Replayed note from bdk pagerduty replay.",
+            trimmed: false,
+            incident: {
+                id: incidentId,
+                type: "incident_reference",
+                html_url: incidentUrl,
+            },
+        }
+        : {
+            id: incidentId,
+            type: "incident",
+            number: 1,
+            title: "Replayed incident from bdk pagerduty replay",
+            status: STATUS_BY_EVENT[input.eventType],
+            urgency: "high",
+            incident_key: `replay-${incidentId}`,
+            html_url: incidentUrl,
+            created_at: new Date().toISOString(),
+            service: SERVICE,
+            assignees: [RESPONDER],
+            teams: [],
+        };
+    return {
+        event: {
+            id: randomUUID(),
+            event_type: input.eventType,
+            resource_type: "incident",
+            occurred_at: new Date().toISOString(),
+            agent: input.eventType === "incident.triggered" ? null : RESPONDER,
+            client: { name: "bdk pagerduty replay" },
+            data,
+        },
+    };
+}

package/dist/channels/pagerduty/secrets.d.ts

@@ -0,0 +1,16 @@
+/**
+ * How a PagerDuty setting turns into a value. An omitted setting reads its
+ * well-known env var / deployment secret, which on Cursor hosting is the
+ * addressed installation's own secret of that name. An authored
+ * `{ secretName }` reads that secret instead and never falls back.
+ */
+import { type WebhookSecretValue } from "../../internal/named-webhook-secret.js";
+/**
+ * The secret name a setting reads: the authored `{ secretName }`, the
+ * default name when the setting is omitted, or `undefined` for a literal
+ * or getter authored in code.
+ */
+export declare function pagerDutySecretName(value: WebhookSecretValue | undefined, defaultName: string): string | undefined;
+/** The setting's value, read now; blank counts as unset. */
+export declare function resolvePagerDutySecret(value: WebhookSecretValue | undefined, defaultName: string): string | undefined;
+//# sourceMappingURL=secrets.d.ts.map

package/dist/channels/pagerduty/secrets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secrets.d.ts","sourceRoot":"","sources":["../../../src/channels/pagerduty/secrets.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,wCAAwC,CAAC;AAGhD;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,kBAAkB,GAAG,SAAS,EACrC,WAAW,EAAE,MAAM,GAClB,MAAM,GAAG,SAAS,CAKpB;AAED,4DAA4D;AAC5D,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,kBAAkB,GAAG,SAAS,EACrC,WAAW,EAAE,MAAM,GAClB,MAAM,GAAG,SAAS,CAEpB"}

package/dist/channels/pagerduty/secrets.js

@@ -0,0 +1,23 @@
+/**
+ * How a PagerDuty setting turns into a value. An omitted setting reads its
+ * well-known env var / deployment secret, which on Cursor hosting is the
+ * addressed installation's own secret of that name. An authored
+ * `{ secretName }` reads that secret instead and never falls back.
+ */
+import { resolveWebhookSecretValue, } from "../../internal/named-webhook-secret.js";
+import { isSecretRef } from "../../types.js";
+/**
+ * The secret name a setting reads: the authored `{ secretName }`, the
+ * default name when the setting is omitted, or `undefined` for a literal
+ * or getter authored in code.
+ */
+export function pagerDutySecretName(value, defaultName) {
+    if (value === undefined) {
+        return defaultName;
+    }
+    return isSecretRef(value) ? value.secretName : undefined;
+}
+/** The setting's value, read now; blank counts as unset. */
+export function resolvePagerDutySecret(value, defaultName) {
+    return resolveWebhookSecretValue(value ?? { secretName: defaultName });
+}