@blokjs/trigger-webhook 0.2.1 → 0.6.2

package/dist/verifiers.js

@@ -0,0 +1,294 @@
+/**
+ * Webhook signature verifiers — one strategy per supported provider.
+ *
+ * Each verifier reads the raw request bytes (NOT the JSON-parsed body)
+ * and the provider-specific signature header, computes the expected
+ * HMAC against a shared secret, and constant-time compares. On match,
+ * returns `{ ok: true, eventId, eventType }`. On mismatch / missing
+ * header / drift, returns `{ ok: false, reason, message }`.
+ *
+ * Constant-time comparison via `crypto.timingSafeEqual` is mandatory —
+ * a naive `===` compare leaks the expected HMAC byte by byte through
+ * timing variance and a network-adjacent attacker can recover the
+ * secret in ~256 requests per byte.
+ *
+ * Built-in providers + their signature shapes:
+ *
+ *   - **github**:    `X-Hub-Signature-256: sha256=<hex>` over rawBody.
+ *                    Event id from `X-GitHub-Delivery`; event type
+ *                    from `X-GitHub-Event` header.
+ *   - **stripe**:    `Stripe-Signature: t=<ts>,v1=<hex>` over
+ *                    `<ts>.<rawBody>` with a 5-minute drift window.
+ *                    Event id + type from body.id / body.type.
+ *   - **slack**:     `X-Slack-Signature: v0=<hex>` over
+ *                    `v0:<X-Slack-Request-Timestamp>:<rawBody>` with a
+ *                    5-minute drift window. Event type from
+ *                    body.event.type; event id from body.event_id.
+ *   - **shopify**:   `X-Shopify-Hmac-Sha256: <base64>` over rawBody.
+ *                    Event type from `X-Shopify-Topic`; event id from
+ *                    `X-Shopify-Webhook-Id`.
+ *   - **svix**:      Standard Webhooks. `webhook-signature:
+ *                    v1,<base64>` over `<webhook-id>.<webhook-timestamp>.<rawBody>`
+ *                    with a 5-minute drift window. Event id from
+ *                    `webhook-id`; event type from body.type.
+ *
+ * Custom (unknown provider) verifier is built dynamically by
+ * `buildCustomVerifier()` from the workflow's `signature` config.
+ */
+import { createHmac, timingSafeEqual } from "node:crypto";
+const DEFAULT_TOLERANCE_SEC = 300;
+function safeEqualString(a, b) {
+    const aBuf = Buffer.from(a);
+    const bBuf = Buffer.from(b);
+    if (aBuf.length !== bBuf.length)
+        return false;
+    return timingSafeEqual(aBuf, bBuf);
+}
+function hmacHex(algo, secret, data) {
+    return createHmac(algo, secret).update(data).digest("hex");
+}
+function hmacBase64(algo, secret, data) {
+    return createHmac(algo, secret).update(data).digest("base64");
+}
+function isWithinTolerance(timestampSec, toleranceSec) {
+    const nowSec = Math.floor(Date.now() / 1000);
+    return Math.abs(nowSec - timestampSec) <= toleranceSec;
+}
+function getEventTypeFromBody(parsedBody, key = "type") {
+    if (!parsedBody || typeof parsedBody !== "object")
+        return undefined;
+    const value = parsedBody[key];
+    return typeof value === "string" ? value : undefined;
+}
+// =============================================================================
+// Built-in providers
+// =============================================================================
+export const githubVerifier = {
+    verify({ headers, rawBody, secret }) {
+        if (!secret)
+            return { ok: false, reason: "missing_secret", message: "GitHub: secret not configured" };
+        const sig = headers["x-hub-signature-256"];
+        if (!sig)
+            return { ok: false, reason: "missing_signature", message: "GitHub: X-Hub-Signature-256 header missing" };
+        const expected = `sha256=${hmacHex("sha256", secret, rawBody)}`;
+        if (!safeEqualString(sig, expected)) {
+            return { ok: false, reason: "signature_mismatch", message: "GitHub: signature mismatch" };
+        }
+        return {
+            ok: true,
+            eventId: headers["x-github-delivery"] ?? "",
+            eventType: headers["x-github-event"] ?? "unknown",
+        };
+    },
+};
+export const stripeVerifier = {
+    verify({ headers, rawBody, parsedBody, secret, toleranceSec }) {
+        if (!secret)
+            return { ok: false, reason: "missing_secret", message: "Stripe: secret not configured" };
+        const sig = headers["stripe-signature"];
+        if (!sig)
+            return { ok: false, reason: "missing_signature", message: "Stripe: Stripe-Signature header missing" };
+        // Format: t=1234567890,v1=<hex>,v0=<hex>,...
+        const parts = Object.fromEntries(sig
+            .split(",")
+            .map((p) => p.trim())
+            .map((p) => {
+            const idx = p.indexOf("=");
+            return idx === -1 ? [p, ""] : [p.slice(0, idx), p.slice(idx + 1)];
+        }));
+        const ts = parts.t;
+        const v1 = parts.v1;
+        if (!ts || !v1) {
+            return {
+                ok: false,
+                reason: "bad_format",
+                message: "Stripe: signature missing t= or v1= component",
+            };
+        }
+        const tsNum = Number.parseInt(ts, 10);
+        if (!Number.isFinite(tsNum)) {
+            return { ok: false, reason: "bad_format", message: "Stripe: t= is not numeric" };
+        }
+        if (!isWithinTolerance(tsNum, toleranceSec || DEFAULT_TOLERANCE_SEC)) {
+            return {
+                ok: false,
+                reason: "timestamp_drift",
+                message: `Stripe: timestamp drift exceeds ${toleranceSec || DEFAULT_TOLERANCE_SEC}s tolerance`,
+            };
+        }
+        const expected = hmacHex("sha256", secret, `${ts}.${rawBody}`);
+        if (!safeEqualString(v1, expected)) {
+            return { ok: false, reason: "signature_mismatch", message: "Stripe: signature mismatch" };
+        }
+        const eventId = parsedBody?.id;
+        const eventType = getEventTypeFromBody(parsedBody);
+        return {
+            ok: true,
+            eventId: typeof eventId === "string" ? eventId : "",
+            eventType: eventType ?? "unknown",
+        };
+    },
+};
+export const slackVerifier = {
+    verify({ headers, rawBody, parsedBody, secret, toleranceSec }) {
+        if (!secret)
+            return { ok: false, reason: "missing_secret", message: "Slack: secret not configured" };
+        const sig = headers["x-slack-signature"];
+        if (!sig)
+            return { ok: false, reason: "missing_signature", message: "Slack: X-Slack-Signature header missing" };
+        const ts = headers["x-slack-request-timestamp"];
+        if (!ts) {
+            return {
+                ok: false,
+                reason: "missing_timestamp",
+                message: "Slack: X-Slack-Request-Timestamp header missing",
+            };
+        }
+        const tsNum = Number.parseInt(ts, 10);
+        if (!Number.isFinite(tsNum)) {
+            return { ok: false, reason: "bad_format", message: "Slack: timestamp is not numeric" };
+        }
+        if (!isWithinTolerance(tsNum, toleranceSec || DEFAULT_TOLERANCE_SEC)) {
+            return {
+                ok: false,
+                reason: "timestamp_drift",
+                message: `Slack: timestamp drift exceeds ${toleranceSec || DEFAULT_TOLERANCE_SEC}s tolerance`,
+            };
+        }
+        const expected = `v0=${hmacHex("sha256", secret, `v0:${ts}:${rawBody}`)}`;
+        if (!safeEqualString(sig, expected)) {
+            return { ok: false, reason: "signature_mismatch", message: "Slack: signature mismatch" };
+        }
+        const event = parsedBody ?? {};
+        const eventType = typeof event.event?.type === "string" ? event.event.type : "unknown";
+        const eventId = typeof event.event_id === "string" ? event.event_id : "";
+        return { ok: true, eventId, eventType };
+    },
+};
+export const shopifyVerifier = {
+    verify({ headers, rawBody, secret }) {
+        if (!secret)
+            return { ok: false, reason: "missing_secret", message: "Shopify: secret not configured" };
+        const sig = headers["x-shopify-hmac-sha256"];
+        if (!sig) {
+            return { ok: false, reason: "missing_signature", message: "Shopify: X-Shopify-Hmac-Sha256 header missing" };
+        }
+        const expected = hmacBase64("sha256", secret, rawBody);
+        if (!safeEqualString(sig, expected)) {
+            return { ok: false, reason: "signature_mismatch", message: "Shopify: signature mismatch" };
+        }
+        return {
+            ok: true,
+            eventId: headers["x-shopify-webhook-id"] ?? "",
+            eventType: headers["x-shopify-topic"] ?? "unknown",
+        };
+    },
+};
+export const svixVerifier = {
+    verify({ headers, rawBody, parsedBody, secret, toleranceSec }) {
+        if (!secret)
+            return { ok: false, reason: "missing_secret", message: "Svix: secret not configured" };
+        const webhookId = headers["webhook-id"];
+        const webhookTs = headers["webhook-timestamp"];
+        const webhookSig = headers["webhook-signature"];
+        if (!webhookId || !webhookTs || !webhookSig) {
+            return {
+                ok: false,
+                reason: "missing_signature",
+                message: "Svix/Standard Webhooks: missing webhook-id, webhook-timestamp, or webhook-signature header",
+            };
+        }
+        const tsNum = Number.parseInt(webhookTs, 10);
+        if (!Number.isFinite(tsNum)) {
+            return { ok: false, reason: "bad_format", message: "Svix: webhook-timestamp is not numeric" };
+        }
+        if (!isWithinTolerance(tsNum, toleranceSec || DEFAULT_TOLERANCE_SEC)) {
+            return {
+                ok: false,
+                reason: "timestamp_drift",
+                message: `Svix: timestamp drift exceeds ${toleranceSec || DEFAULT_TOLERANCE_SEC}s tolerance`,
+            };
+        }
+        const signed = `${webhookId}.${webhookTs}.${rawBody}`;
+        // Strip optional `whsec_` prefix Svix recommends for secrets.
+        const rawSecret = secret.startsWith("whsec_") ? secret.slice("whsec_".length) : secret;
+        // Svix encodes the secret as base64 — decode before HMAC.
+        const secretBuf = Buffer.from(rawSecret, "base64");
+        const expected = createHmac("sha256", secretBuf).update(signed).digest("base64");
+        // webhook-signature may include multiple versions: `v1,base64 v1,base64 ...`
+        const sigs = webhookSig.split(" ").map((s) => {
+            const idx = s.indexOf(",");
+            return idx === -1 ? s : s.slice(idx + 1);
+        });
+        const matched = sigs.some((s) => safeEqualString(s, expected));
+        if (!matched) {
+            return { ok: false, reason: "signature_mismatch", message: "Svix: signature mismatch" };
+        }
+        return {
+            ok: true,
+            eventId: webhookId,
+            eventType: getEventTypeFromBody(parsedBody) ?? "unknown",
+        };
+    },
+};
+export function buildCustomVerifier(config) {
+    const algo = config.scheme === "hmac-sha1" ? "sha1" : config.scheme === "hmac-sha512" ? "sha512" : "sha256";
+    const headerLower = config.header.toLowerCase();
+    const tsHeaderLower = config.timestampHeader?.toLowerCase();
+    return {
+        verify({ headers, rawBody, parsedBody, secret, toleranceSec }) {
+            if (!secret)
+                return { ok: false, reason: "missing_secret", message: `${config.header}: secret not configured` };
+            const sig = headers[headerLower];
+            if (!sig) {
+                return { ok: false, reason: "missing_signature", message: `${config.header}: header missing` };
+            }
+            let signedString = rawBody;
+            if (tsHeaderLower) {
+                const ts = headers[tsHeaderLower];
+                if (!ts) {
+                    return {
+                        ok: false,
+                        reason: "missing_timestamp",
+                        message: `${config.timestampHeader}: header missing`,
+                    };
+                }
+                const tsNum = Number.parseInt(ts, 10);
+                if (!Number.isFinite(tsNum)) {
+                    return {
+                        ok: false,
+                        reason: "bad_format",
+                        message: `${config.timestampHeader}: not numeric`,
+                    };
+                }
+                if (!isWithinTolerance(tsNum, toleranceSec || config.tolerance)) {
+                    return {
+                        ok: false,
+                        reason: "timestamp_drift",
+                        message: `Timestamp drift exceeds ${toleranceSec || config.tolerance}s tolerance`,
+                    };
+                }
+                signedString = `${ts}.${rawBody}`;
+            }
+            const hex = hmacHex(algo, secret, signedString);
+            const base64 = hmacBase64(algo, secret, signedString);
+            const expected = config.format.replace("{hex}", hex).replace("{base64}", base64);
+            if (!safeEqualString(sig, expected)) {
+                return { ok: false, reason: "signature_mismatch", message: `${config.header}: signature mismatch` };
+            }
+            return {
+                ok: true,
+                eventId: "",
+                eventType: getEventTypeFromBody(parsedBody) ?? "unknown",
+            };
+        },
+    };
+}
+export const BUILTIN_VERIFIERS = {
+    github: githubVerifier,
+    stripe: stripeVerifier,
+    slack: slackVerifier,
+    shopify: shopifyVerifier,
+    svix: svixVerifier,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"verifiers.js","sourceRoot":"","sources":["../src/verifiers.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Webhook signature verifiers — one strategy per supported provider.\n *\n * Each verifier reads the raw request bytes (NOT the JSON-parsed body)\n * and the provider-specific signature header, computes the expected\n * HMAC against a shared secret, and constant-time compares. On match,\n * returns `{ ok: true, eventId, eventType }`. On mismatch / missing\n * header / drift, returns `{ ok: false, reason, message }`.\n *\n * Constant-time comparison via `crypto.timingSafeEqual` is mandatory —\n * a naive `===` compare leaks the expected HMAC byte by byte through\n * timing variance and a network-adjacent attacker can recover the\n * secret in ~256 requests per byte.\n *\n * Built-in providers + their signature shapes:\n *\n *   - **github**:    `X-Hub-Signature-256: sha256=<hex>` over rawBody.\n *                    Event id from `X-GitHub-Delivery`; event type\n *                    from `X-GitHub-Event` header.\n *   - **stripe**:    `Stripe-Signature: t=<ts>,v1=<hex>` over\n *                    `<ts>.<rawBody>` with a 5-minute drift window.\n *                    Event id + type from body.id / body.type.\n *   - **slack**:     `X-Slack-Signature: v0=<hex>` over\n *                    `v0:<X-Slack-Request-Timestamp>:<rawBody>` with a\n *                    5-minute drift window. Event type from\n *                    body.event.type; event id from body.event_id.\n *   - **shopify**:   `X-Shopify-Hmac-Sha256: <base64>` over rawBody.\n *                    Event type from `X-Shopify-Topic`; event id from\n *                    `X-Shopify-Webhook-Id`.\n *   - **svix**:      Standard Webhooks. `webhook-signature:\n *                    v1,<base64>` over `<webhook-id>.<webhook-timestamp>.<rawBody>`\n *                    with a 5-minute drift window. Event id from\n *                    `webhook-id`; event type from body.type.\n *\n * Custom (unknown provider) verifier is built dynamically by\n * `buildCustomVerifier()` from the workflow's `signature` config.\n */\n\nimport { createHmac, timingSafeEqual } from \"node:crypto\";\n\n/** Successful verification result — workflow may proceed. */\nexport interface VerifyOk {\n\tok: true;\n\t/** Provider-specific event id (used for replay-protection cache key). */\n\teventId: string;\n\t/** Provider-specific event type (used for the allowlist check). */\n\teventType: string;\n}\n\n/** Verification failure — trigger returns 401 with structured reason. */\nexport interface VerifyError {\n\tok: false;\n\t/** Stable discriminator — log/alert dashboards branch on this. */\n\treason:\n\t\t| \"missing_signature\"\n\t\t| \"missing_timestamp\"\n\t\t| \"missing_secret\"\n\t\t| \"bad_format\"\n\t\t| \"timestamp_drift\"\n\t\t| \"signature_mismatch\";\n\t/** Human-readable error message. Safe to surface to the sender. */\n\tmessage: string;\n}\n\nexport type VerifyResult = VerifyOk | VerifyError;\n\n/** Inputs every verifier receives. */\nexport interface VerifyInput {\n\theaders: Record<string, string>;\n\trawBody: string;\n\tparsedBody: unknown;\n\tsecret: string;\n\ttoleranceSec: number;\n}\n\nexport interface Verifier {\n\tverify(input: VerifyInput): VerifyResult;\n}\n\nconst DEFAULT_TOLERANCE_SEC = 300;\n\nfunction safeEqualString(a: string, b: string): boolean {\n\tconst aBuf = Buffer.from(a);\n\tconst bBuf = Buffer.from(b);\n\tif (aBuf.length !== bBuf.length) return false;\n\treturn timingSafeEqual(aBuf, bBuf);\n}\n\nfunction hmacHex(algo: \"sha256\" | \"sha1\" | \"sha512\", secret: string, data: string): string {\n\treturn createHmac(algo, secret).update(data).digest(\"hex\");\n}\n\nfunction hmacBase64(algo: \"sha256\" | \"sha1\" | \"sha512\", secret: string, data: string): string {\n\treturn createHmac(algo, secret).update(data).digest(\"base64\");\n}\n\nfunction isWithinTolerance(timestampSec: number, toleranceSec: number): boolean {\n\tconst nowSec = Math.floor(Date.now() / 1000);\n\treturn Math.abs(nowSec - timestampSec) <= toleranceSec;\n}\n\nfunction getEventTypeFromBody(parsedBody: unknown, key = \"type\"): string | undefined {\n\tif (!parsedBody || typeof parsedBody !== \"object\") return undefined;\n\tconst value = (parsedBody as Record<string, unknown>)[key];\n\treturn typeof value === \"string\" ? value : undefined;\n}\n\n// =============================================================================\n// Built-in providers\n// =============================================================================\n\nexport const githubVerifier: Verifier = {\n\tverify({ headers, rawBody, secret }) {\n\t\tif (!secret) return { ok: false, reason: \"missing_secret\", message: \"GitHub: secret not configured\" };\n\t\tconst sig = headers[\"x-hub-signature-256\"];\n\t\tif (!sig) return { ok: false, reason: \"missing_signature\", message: \"GitHub: X-Hub-Signature-256 header missing\" };\n\t\tconst expected = `sha256=${hmacHex(\"sha256\", secret, rawBody)}`;\n\t\tif (!safeEqualString(sig, expected)) {\n\t\t\treturn { ok: false, reason: \"signature_mismatch\", message: \"GitHub: signature mismatch\" };\n\t\t}\n\t\treturn {\n\t\t\tok: true,\n\t\t\teventId: headers[\"x-github-delivery\"] ?? \"\",\n\t\t\teventType: headers[\"x-github-event\"] ?? \"unknown\",\n\t\t};\n\t},\n};\n\nexport const stripeVerifier: Verifier = {\n\tverify({ headers, rawBody, parsedBody, secret, toleranceSec }) {\n\t\tif (!secret) return { ok: false, reason: \"missing_secret\", message: \"Stripe: secret not configured\" };\n\t\tconst sig = headers[\"stripe-signature\"];\n\t\tif (!sig) return { ok: false, reason: \"missing_signature\", message: \"Stripe: Stripe-Signature header missing\" };\n\n\t\t// Format: t=1234567890,v1=<hex>,v0=<hex>,...\n\t\tconst parts = Object.fromEntries(\n\t\t\tsig\n\t\t\t\t.split(\",\")\n\t\t\t\t.map((p) => p.trim())\n\t\t\t\t.map((p) => {\n\t\t\t\t\tconst idx = p.indexOf(\"=\");\n\t\t\t\t\treturn idx === -1 ? [p, \"\"] : [p.slice(0, idx), p.slice(idx + 1)];\n\t\t\t\t}),\n\t\t);\n\t\tconst ts = parts.t;\n\t\tconst v1 = parts.v1;\n\t\tif (!ts || !v1) {\n\t\t\treturn {\n\t\t\t\tok: false,\n\t\t\t\treason: \"bad_format\",\n\t\t\t\tmessage: \"Stripe: signature missing t= or v1= component\",\n\t\t\t};\n\t\t}\n\t\tconst tsNum = Number.parseInt(ts, 10);\n\t\tif (!Number.isFinite(tsNum)) {\n\t\t\treturn { ok: false, reason: \"bad_format\", message: \"Stripe: t= is not numeric\" };\n\t\t}\n\t\tif (!isWithinTolerance(tsNum, toleranceSec || DEFAULT_TOLERANCE_SEC)) {\n\t\t\treturn {\n\t\t\t\tok: false,\n\t\t\t\treason: \"timestamp_drift\",\n\t\t\t\tmessage: `Stripe: timestamp drift exceeds ${toleranceSec || DEFAULT_TOLERANCE_SEC}s tolerance`,\n\t\t\t};\n\t\t}\n\t\tconst expected = hmacHex(\"sha256\", secret, `${ts}.${rawBody}`);\n\t\tif (!safeEqualString(v1, expected)) {\n\t\t\treturn { ok: false, reason: \"signature_mismatch\", message: \"Stripe: signature mismatch\" };\n\t\t}\n\t\tconst eventId = (parsedBody as { id?: unknown } | null)?.id;\n\t\tconst eventType = getEventTypeFromBody(parsedBody);\n\t\treturn {\n\t\t\tok: true,\n\t\t\teventId: typeof eventId === \"string\" ? eventId : \"\",\n\t\t\teventType: eventType ?? \"unknown\",\n\t\t};\n\t},\n};\n\nexport const slackVerifier: Verifier = {\n\tverify({ headers, rawBody, parsedBody, secret, toleranceSec }) {\n\t\tif (!secret) return { ok: false, reason: \"missing_secret\", message: \"Slack: secret not configured\" };\n\t\tconst sig = headers[\"x-slack-signature\"];\n\t\tif (!sig) return { ok: false, reason: \"missing_signature\", message: \"Slack: X-Slack-Signature header missing\" };\n\t\tconst ts = headers[\"x-slack-request-timestamp\"];\n\t\tif (!ts) {\n\t\t\treturn {\n\t\t\t\tok: false,\n\t\t\t\treason: \"missing_timestamp\",\n\t\t\t\tmessage: \"Slack: X-Slack-Request-Timestamp header missing\",\n\t\t\t};\n\t\t}\n\t\tconst tsNum = Number.parseInt(ts, 10);\n\t\tif (!Number.isFinite(tsNum)) {\n\t\t\treturn { ok: false, reason: \"bad_format\", message: \"Slack: timestamp is not numeric\" };\n\t\t}\n\t\tif (!isWithinTolerance(tsNum, toleranceSec || DEFAULT_TOLERANCE_SEC)) {\n\t\t\treturn {\n\t\t\t\tok: false,\n\t\t\t\treason: \"timestamp_drift\",\n\t\t\t\tmessage: `Slack: timestamp drift exceeds ${toleranceSec || DEFAULT_TOLERANCE_SEC}s tolerance`,\n\t\t\t};\n\t\t}\n\t\tconst expected = `v0=${hmacHex(\"sha256\", secret, `v0:${ts}:${rawBody}`)}`;\n\t\tif (!safeEqualString(sig, expected)) {\n\t\t\treturn { ok: false, reason: \"signature_mismatch\", message: \"Slack: signature mismatch\" };\n\t\t}\n\t\tconst event = (parsedBody as { event?: { type?: unknown }; event_id?: unknown } | null) ?? {};\n\t\tconst eventType = typeof event.event?.type === \"string\" ? event.event.type : \"unknown\";\n\t\tconst eventId = typeof event.event_id === \"string\" ? event.event_id : \"\";\n\t\treturn { ok: true, eventId, eventType };\n\t},\n};\n\nexport const shopifyVerifier: Verifier = {\n\tverify({ headers, rawBody, secret }) {\n\t\tif (!secret) return { ok: false, reason: \"missing_secret\", message: \"Shopify: secret not configured\" };\n\t\tconst sig = headers[\"x-shopify-hmac-sha256\"];\n\t\tif (!sig) {\n\t\t\treturn { ok: false, reason: \"missing_signature\", message: \"Shopify: X-Shopify-Hmac-Sha256 header missing\" };\n\t\t}\n\t\tconst expected = hmacBase64(\"sha256\", secret, rawBody);\n\t\tif (!safeEqualString(sig, expected)) {\n\t\t\treturn { ok: false, reason: \"signature_mismatch\", message: \"Shopify: signature mismatch\" };\n\t\t}\n\t\treturn {\n\t\t\tok: true,\n\t\t\teventId: headers[\"x-shopify-webhook-id\"] ?? \"\",\n\t\t\teventType: headers[\"x-shopify-topic\"] ?? \"unknown\",\n\t\t};\n\t},\n};\n\nexport const svixVerifier: Verifier = {\n\tverify({ headers, rawBody, parsedBody, secret, toleranceSec }) {\n\t\tif (!secret) return { ok: false, reason: \"missing_secret\", message: \"Svix: secret not configured\" };\n\t\tconst webhookId = headers[\"webhook-id\"];\n\t\tconst webhookTs = headers[\"webhook-timestamp\"];\n\t\tconst webhookSig = headers[\"webhook-signature\"];\n\t\tif (!webhookId || !webhookTs || !webhookSig) {\n\t\t\treturn {\n\t\t\t\tok: false,\n\t\t\t\treason: \"missing_signature\",\n\t\t\t\tmessage: \"Svix/Standard Webhooks: missing webhook-id, webhook-timestamp, or webhook-signature header\",\n\t\t\t};\n\t\t}\n\t\tconst tsNum = Number.parseInt(webhookTs, 10);\n\t\tif (!Number.isFinite(tsNum)) {\n\t\t\treturn { ok: false, reason: \"bad_format\", message: \"Svix: webhook-timestamp is not numeric\" };\n\t\t}\n\t\tif (!isWithinTolerance(tsNum, toleranceSec || DEFAULT_TOLERANCE_SEC)) {\n\t\t\treturn {\n\t\t\t\tok: false,\n\t\t\t\treason: \"timestamp_drift\",\n\t\t\t\tmessage: `Svix: timestamp drift exceeds ${toleranceSec || DEFAULT_TOLERANCE_SEC}s tolerance`,\n\t\t\t};\n\t\t}\n\t\tconst signed = `${webhookId}.${webhookTs}.${rawBody}`;\n\t\t// Strip optional `whsec_` prefix Svix recommends for secrets.\n\t\tconst rawSecret = secret.startsWith(\"whsec_\") ? secret.slice(\"whsec_\".length) : secret;\n\t\t// Svix encodes the secret as base64 — decode before HMAC.\n\t\tconst secretBuf = Buffer.from(rawSecret, \"base64\");\n\t\tconst expected = createHmac(\"sha256\", secretBuf).update(signed).digest(\"base64\");\n\t\t// webhook-signature may include multiple versions: `v1,base64 v1,base64 ...`\n\t\tconst sigs = webhookSig.split(\" \").map((s) => {\n\t\t\tconst idx = s.indexOf(\",\");\n\t\t\treturn idx === -1 ? s : s.slice(idx + 1);\n\t\t});\n\t\tconst matched = sigs.some((s) => safeEqualString(s, expected));\n\t\tif (!matched) {\n\t\t\treturn { ok: false, reason: \"signature_mismatch\", message: \"Svix: signature mismatch\" };\n\t\t}\n\t\treturn {\n\t\t\tok: true,\n\t\t\teventId: webhookId,\n\t\t\teventType: getEventTypeFromBody(parsedBody) ?? \"unknown\",\n\t\t};\n\t},\n};\n\n// =============================================================================\n// Custom verifier — built from the workflow's `signature: { ... }` config\n// =============================================================================\n\nexport interface CustomSignatureConfig {\n\tscheme: \"hmac-sha256\" | \"hmac-sha1\" | \"hmac-sha512\";\n\theader: string;\n\tformat: string;\n\tsecretEnv: string;\n\ttolerance: number;\n\ttimestampHeader?: string;\n}\n\nexport function buildCustomVerifier(config: CustomSignatureConfig): Verifier {\n\tconst algo: \"sha256\" | \"sha1\" | \"sha512\" =\n\t\tconfig.scheme === \"hmac-sha1\" ? \"sha1\" : config.scheme === \"hmac-sha512\" ? \"sha512\" : \"sha256\";\n\tconst headerLower = config.header.toLowerCase();\n\tconst tsHeaderLower = config.timestampHeader?.toLowerCase();\n\n\treturn {\n\t\tverify({ headers, rawBody, parsedBody, secret, toleranceSec }) {\n\t\t\tif (!secret) return { ok: false, reason: \"missing_secret\", message: `${config.header}: secret not configured` };\n\t\t\tconst sig = headers[headerLower];\n\t\t\tif (!sig) {\n\t\t\t\treturn { ok: false, reason: \"missing_signature\", message: `${config.header}: header missing` };\n\t\t\t}\n\n\t\t\tlet signedString = rawBody;\n\t\t\tif (tsHeaderLower) {\n\t\t\t\tconst ts = headers[tsHeaderLower];\n\t\t\t\tif (!ts) {\n\t\t\t\t\treturn {\n\t\t\t\t\t\tok: false,\n\t\t\t\t\t\treason: \"missing_timestamp\",\n\t\t\t\t\t\tmessage: `${config.timestampHeader}: header missing`,\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t\tconst tsNum = Number.parseInt(ts, 10);\n\t\t\t\tif (!Number.isFinite(tsNum)) {\n\t\t\t\t\treturn {\n\t\t\t\t\t\tok: false,\n\t\t\t\t\t\treason: \"bad_format\",\n\t\t\t\t\t\tmessage: `${config.timestampHeader}: not numeric`,\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t\tif (!isWithinTolerance(tsNum, toleranceSec || config.tolerance)) {\n\t\t\t\t\treturn {\n\t\t\t\t\t\tok: false,\n\t\t\t\t\t\treason: \"timestamp_drift\",\n\t\t\t\t\t\tmessage: `Timestamp drift exceeds ${toleranceSec || config.tolerance}s tolerance`,\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t\tsignedString = `${ts}.${rawBody}`;\n\t\t\t}\n\n\t\t\tconst hex = hmacHex(algo, secret, signedString);\n\t\t\tconst base64 = hmacBase64(algo, secret, signedString);\n\t\t\tconst expected = config.format.replace(\"{hex}\", hex).replace(\"{base64}\", base64);\n\n\t\t\tif (!safeEqualString(sig, expected)) {\n\t\t\t\treturn { ok: false, reason: \"signature_mismatch\", message: `${config.header}: signature mismatch` };\n\t\t\t}\n\t\t\treturn {\n\t\t\t\tok: true,\n\t\t\t\teventId: \"\",\n\t\t\t\teventType: getEventTypeFromBody(parsedBody) ?? \"unknown\",\n\t\t\t};\n\t\t},\n\t};\n}\n\nexport const BUILTIN_VERIFIERS: Record<string, Verifier> = {\n\tgithub: githubVerifier,\n\tstripe: stripeVerifier,\n\tslack: slackVerifier,\n\tshopify: shopifyVerifier,\n\tsvix: svixVerifier,\n};\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@blokjs/trigger-webhook",
-	"version": "0.2.1",
+	"version": "0.6.2",
 	"description": "Webhook trigger for Blok workflows - supports GitHub, Stripe, Shopify, and custom webhooks",
 	"type": "module",
 	"main": "dist/index.js",
@@ -14,13 +14,15 @@
 	"author": "Deskree Technologies Inc.",
 	"license": "Apache-2.0",
 	"dependencies": {
-		"@blokjs/helper": "^0.2.0",
-		"@blokjs/runner": "^0.2.0",
-		"@blokjs/shared": "^0.2.0",
+		"@blokjs/helper": "^0.6.2",
+		"@blokjs/runner": "^0.6.2",
+		"@blokjs/shared": "^0.6.2",
 		"@opentelemetry/api": "^1.9.0",
+		"hono": "^4.11.7",
 		"uuid": "^11.1.0"
 	},
 	"devDependencies": {
+		"@hono/node-server": "^1.19.9",
 		"@types/node": "^22.15.21",
 		"@types/uuid": "^11.0.0",
 		"typescript": "^5.8.3",

package/src/WebhookTrigger.integration.test.ts

@@ -0,0 +1,162 @@
+/**
+ * v0.7 PR 4 — full end-to-end webhook trigger integration test.
+ *
+ * Spins up a real Hono app + `@hono/node-server` with a real
+ * WebhookTrigger configured for a GitHub-style provider. Sends a
+ * signed POST via native `fetch` and asserts the workflow ran. A
+ * second POST with the same delivery id exercises the replay-cache
+ * dedup path and expects `{ status: "duplicate" }`.
+ *
+ * Complements `WebhookTrigger.test.ts` + `verifiers.test.ts` (unit
+ * coverage of the public surface).
+ */
+
+import { createHmac } from "node:crypto";
+import type { Server } from "node:http";
+import { NodeMap, RunTracker, WorkflowRegistry, defineNode } from "@blokjs/runner";
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { z } from "zod";
+
+vi.mock("@opentelemetry/api", () => ({
+	trace: {
+		getTracer: () => ({
+			startActiveSpan: (_name: string, fn: (span: unknown) => unknown) =>
+				fn({ setAttribute: vi.fn(), setStatus: vi.fn(), recordException: vi.fn(), end: vi.fn() }),
+		}),
+	},
+	metrics: {
+		getMeter: () => ({
+			createCounter: () => ({ add: vi.fn() }),
+			createHistogram: () => ({ record: vi.fn() }),
+			createGauge: () => ({ record: vi.fn() }),
+			createObservableGauge: () => ({ addCallback: vi.fn() }),
+		}),
+	},
+	SpanStatusCode: { OK: 0, ERROR: 1 },
+}));
+
+import WebhookTriggerClass, { _setActiveWebhookTrigger } from "./WebhookTrigger";
+
+const TEST_PORT = 4903;
+const SECRET = "shhh-its-a-secret-1234567890";
+
+function hmacHex(body: string): string {
+	return createHmac("sha256", SECRET).update(body).digest("hex");
+}
+
+const handleNode = defineNode({
+	name: "handle-event",
+	description: "test fixture — record the event id + type",
+	input: z.object({}).passthrough(),
+	output: z.object({ handled: z.boolean(), eventId: z.string() }),
+	async execute(ctx) {
+		const body = (ctx.request?.body as { delivery_id?: string } | undefined) ?? {};
+		return { handled: true, eventId: body.delivery_id ?? "" };
+	},
+});
+
+describe("WebhookTrigger — v0.7 PR 4 integration (real HTTP)", () => {
+	let app: Hono;
+	let trigger: InstanceType<typeof WebhookTriggerClass>;
+	let httpServer: Server | null = null;
+
+	beforeEach(() => {
+		WorkflowRegistry.resetInstance();
+		_setActiveWebhookTrigger(null);
+		process.env.GH_SECRET = SECRET;
+		app = new Hono();
+	});
+
+	afterEach(
+		() =>
+			new Promise<void>((resolve) => {
+				if (trigger) void trigger.stop();
+				if (httpServer) {
+					httpServer.close(() => {
+						httpServer = null;
+						WorkflowRegistry.resetInstance();
+						_setActiveWebhookTrigger(null);
+						process.env.GH_SECRET = undefined;
+						resolve();
+					});
+				} else {
+					WorkflowRegistry.resetInstance();
+					_setActiveWebhookTrigger(null);
+					process.env.GH_SECRET = undefined;
+					resolve();
+				}
+			}),
+	);
+
+	it("verifies a signed GitHub-style POST, runs the workflow, and dedups replays", async () => {
+		const nodes = new NodeMap();
+		nodes.addNode("handle-event", handleNode);
+
+		WorkflowRegistry.getInstance().register({
+			name: "gh-events",
+			source: "/test/gh.json",
+			workflow: {
+				name: "gh-events",
+				version: "1.0.0",
+				trigger: {
+					webhook: {
+						provider: "github",
+						path: "/webhooks/github",
+						secretEnv: "GH_SECRET",
+						idempotencyKey: "js/ctx.request.headers['x-github-delivery']",
+					},
+				},
+				steps: [{ id: "handle", node: "handle-event", type: "module", inputs: {} }],
+				nodes: { handle: { inputs: {} } },
+			},
+		});
+
+		trigger = new WebhookTriggerClass(app);
+		trigger.setNodeMap({ nodes });
+		await trigger.listen();
+
+		await new Promise<void>((resolve) => {
+			httpServer = serve({ fetch: app.fetch, port: TEST_PORT }, () => resolve()) as Server;
+		});
+
+		const body = JSON.stringify({ ref: "refs/heads/main", delivery_id: "delivery-uuid-9" });
+		const sig = `sha256=${hmacHex(body)}`;
+		const reqInit = {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				"x-hub-signature-256": sig,
+				"x-github-event": "push",
+				"x-github-delivery": "delivery-uuid-9",
+			},
+			body,
+		};
+
+		// First delivery — should run the workflow.
+		const first = await fetch(`http://localhost:${TEST_PORT}/webhooks/github`, reqInit);
+		expect(first.status).toBe(200);
+		const firstJson = (await first.json()) as { status?: string; eventId?: string };
+		expect(firstJson.status).toBe("ok");
+		expect(firstJson.eventId).toBe("delivery-uuid-9");
+
+		// Second delivery with the same delivery id — replay cache should
+		// short-circuit with `duplicate` and NOT run the workflow.
+		const second = await fetch(`http://localhost:${TEST_PORT}/webhooks/github`, reqInit);
+		expect(second.status).toBe(200);
+		const secondJson = (await second.json()) as { status?: string; eventId?: string };
+		expect(secondJson.status).toBe("duplicate");
+		expect(secondJson.eventId).toBe("delivery-uuid-9");
+	}, 15_000);
+});
+
+// Drain the per-process RunTracker after the suite to keep singletons
+// from leaking into other tests in the same project.
+afterEach(() => {
+	try {
+		RunTracker.resetInstance();
+	} catch {
+		/* ignore — older test orderings */
+	}
+});