@cstar.help/js 0.14.0 → 0.15.1

package/dist/webhook/index.cjs

@@ -20,19 +20,55 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/webhook/index.ts
 var webhook_exports = {};
 __export(webhook_exports, {
+  DEFAULT_TOLERANCE_SECONDS: () => DEFAULT_TOLERANCE_SECONDS,
   WebhookSignatureVerificationError: () => WebhookSignatureVerificationError,
   constructEventAsync: () => constructEventAsync,
+  signPayloadStripeAsync: () => signPayloadStripeAsync,
   verifySignatureAsync: () => verifySignatureAsync
 });
 module.exports = __toCommonJS(webhook_exports);
+var DEFAULT_TOLERANCE_SECONDS = 300;
 var WebhookSignatureVerificationError = class extends Error {
   constructor(message) {
     super(message);
     this.name = "WebhookSignatureVerificationError";
   }
 };
-async function constructEventAsync(rawBody, signature, secret) {
-  const valid = await verifySignatureAsync(rawBody, signature, secret);
+function parseStripeHeader(header) {
+  if (!header || header.startsWith("sha256=")) return null;
+  let timestamp = null;
+  const v1 = [];
+  for (const part of header.split(",")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    const key = part.slice(0, eq).trim();
+    const value = part.slice(eq + 1).trim();
+    if (key === "t") {
+      const parsed = Number.parseInt(value, 10);
+      if (Number.isFinite(parsed)) timestamp = parsed;
+    } else if (key === "v1") {
+      v1.push(value);
+    }
+  }
+  if (timestamp === null || v1.length === 0) return null;
+  return { timestamp, v1 };
+}
+async function signPayloadStripeAsync(rawBody, secret) {
+  const ts = Math.floor(Date.now() / 1e3);
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const sigBytes = await crypto.subtle.sign("HMAC", key, encoder.encode(`${ts}.${rawBody}`));
+  const hex = Array.from(new Uint8Array(sigBytes)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `t=${ts},v1=${hex}`;
+}
+async function constructEventAsync(rawBody, signature, secret, options) {
+  const valid = await verifySignatureAsync(rawBody, signature, secret, options);
   if (!valid) {
     throw new WebhookSignatureVerificationError(
       "Webhook signature verification failed. Ensure you are using the raw request body and the correct endpoint secret."
@@ -40,7 +76,7 @@ async function constructEventAsync(rawBody, signature, secret) {
   }
   return JSON.parse(rawBody);
 }
-async function verifySignatureAsync(rawBody, signature, secret) {
+async function hmacHex(material, secret) {
   const encoder = new TextEncoder();
   const key = await crypto.subtle.importKey(
     "raw",
@@ -49,18 +85,38 @@ async function verifySignatureAsync(rawBody, signature, secret) {
     false,
     ["sign"]
   );
-  const sig = await crypto.subtle.sign("HMAC", key, encoder.encode(rawBody));
-  const expected = "sha256=" + Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
-  if (signature.length !== expected.length) return false;
+  const sig = await crypto.subtle.sign("HMAC", key, encoder.encode(material));
+  return Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) return false;
   let result = 0;
-  for (let i = 0; i < signature.length; i++) {
-    result |= signature.charCodeAt(i) ^ expected.charCodeAt(i);
+  for (let i = 0; i < a.length; i++) {
+    result |= a.charCodeAt(i) ^ b.charCodeAt(i);
   }
   return result === 0;
 }
+async function verifySignatureAsync(rawBody, signature, secret, options) {
+  if (typeof signature !== "string" || signature.length === 0) return false;
+  const stripe = parseStripeHeader(signature);
+  if (stripe) {
+    const tolerance = options?.tolerance ?? DEFAULT_TOLERANCE_SECONDS;
+    const now = Math.floor(Date.now() / 1e3);
+    if (Math.abs(now - stripe.timestamp) > tolerance) return false;
+    const expected2 = await hmacHex(`${stripe.timestamp}.${rawBody}`, secret);
+    for (const candidate of stripe.v1) {
+      if (constantTimeEqual(candidate, expected2)) return true;
+    }
+    return false;
+  }
+  const expected = "sha256=" + await hmacHex(rawBody, secret);
+  return constantTimeEqual(signature, expected);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DEFAULT_TOLERANCE_SECONDS,
   WebhookSignatureVerificationError,
   constructEventAsync,
+  signPayloadStripeAsync,
   verifySignatureAsync
 });

package/dist/webhook/index.d.cts

@@ -412,10 +412,27 @@ interface WebhookEvent<T extends WebhookEventType = WebhookEventType> {
     data: WebhookEventDataMap[T];
 }
 
+/** Default replay window for Stripe-style signatures: 5 minutes (300s). */
+declare const DEFAULT_TOLERANCE_SECONDS = 300;
+/** Options for signature verification — accepted by both verify and construct calls. */
+interface VerifyOptions {
+    /**
+     * Maximum age (in seconds) of a Stripe-style timestamp before the signature
+     * is rejected as expired. Defaults to {@link DEFAULT_TOLERANCE_SECONDS}.
+     * Ignored for legacy `sha256=<hex>` signatures (which carry no timestamp).
+     */
+    tolerance?: number;
+}
 /** Thrown when webhook signature verification fails. */
 declare class WebhookSignatureVerificationError extends Error {
     constructor(message: string);
 }
+/**
+ * Sign a payload in Stripe-style format `t=<unix>,v1=<hex>` using Web Crypto.
+ * The HMAC is computed over `${ts}.${rawBody}`. Used by the cStar server
+ * dispatcher and `cstar listen --forward-to`.
+ */
+declare function signPayloadStripeAsync(rawBody: string, secret: string): Promise<string>;
 /**
  * Verify a webhook signature and parse the event.
  *
@@ -427,14 +444,21 @@ declare class WebhookSignatureVerificationError extends Error {
  * @param rawBody - Raw request body as a string (NOT parsed JSON)
  * @param signature - Value of the `X-Signature` header
  * @param secret - Your webhook endpoint's secret (`whsec_*`)
+ * @param options - Optional verifier options (e.g. replay tolerance)
  * @returns Parsed and verified webhook event
  * @throws {WebhookSignatureVerificationError} If verification fails
  */
-declare function constructEventAsync(rawBody: string, signature: string, secret: string): Promise<WebhookEvent>;
+declare function constructEventAsync(rawBody: string, signature: string, secret: string, options?: VerifyOptions): Promise<WebhookEvent>;
 /**
  * Verify an HMAC-SHA256 signature using the Web Crypto API.
+ *
+ * Accepts both the canonical Stripe-style format `t=<unix>,v1=<hex>` (signed
+ * over `${ts}.${rawBody}` with replay-window enforcement) and the legacy
+ * `sha256=<hex>` format (signed over `rawBody` only, no timestamp). Use
+ * `options.tolerance` to override the default 300s replay window.
+ *
  * Constant-time comparison to prevent timing attacks.
  */
-declare function verifySignatureAsync(rawBody: string, signature: string, secret: string): Promise<boolean>;
+declare function verifySignatureAsync(rawBody: string, signature: string, secret: string, options?: VerifyOptions): Promise<boolean>;
 
-export { type WebhookEvent, WebhookSignatureVerificationError, constructEventAsync, verifySignatureAsync };
+export { DEFAULT_TOLERANCE_SECONDS, type VerifyOptions, type WebhookEvent, WebhookSignatureVerificationError, constructEventAsync, signPayloadStripeAsync, verifySignatureAsync };

package/dist/webhook/index.d.ts

@@ -412,10 +412,27 @@ interface WebhookEvent<T extends WebhookEventType = WebhookEventType> {
     data: WebhookEventDataMap[T];
 }
 
+/** Default replay window for Stripe-style signatures: 5 minutes (300s). */
+declare const DEFAULT_TOLERANCE_SECONDS = 300;
+/** Options for signature verification — accepted by both verify and construct calls. */
+interface VerifyOptions {
+    /**
+     * Maximum age (in seconds) of a Stripe-style timestamp before the signature
+     * is rejected as expired. Defaults to {@link DEFAULT_TOLERANCE_SECONDS}.
+     * Ignored for legacy `sha256=<hex>` signatures (which carry no timestamp).
+     */
+    tolerance?: number;
+}
 /** Thrown when webhook signature verification fails. */
 declare class WebhookSignatureVerificationError extends Error {
     constructor(message: string);
 }
+/**
+ * Sign a payload in Stripe-style format `t=<unix>,v1=<hex>` using Web Crypto.
+ * The HMAC is computed over `${ts}.${rawBody}`. Used by the cStar server
+ * dispatcher and `cstar listen --forward-to`.
+ */
+declare function signPayloadStripeAsync(rawBody: string, secret: string): Promise<string>;
 /**
  * Verify a webhook signature and parse the event.
  *
@@ -427,14 +444,21 @@ declare class WebhookSignatureVerificationError extends Error {
  * @param rawBody - Raw request body as a string (NOT parsed JSON)
  * @param signature - Value of the `X-Signature` header
  * @param secret - Your webhook endpoint's secret (`whsec_*`)
+ * @param options - Optional verifier options (e.g. replay tolerance)
  * @returns Parsed and verified webhook event
  * @throws {WebhookSignatureVerificationError} If verification fails
  */
-declare function constructEventAsync(rawBody: string, signature: string, secret: string): Promise<WebhookEvent>;
+declare function constructEventAsync(rawBody: string, signature: string, secret: string, options?: VerifyOptions): Promise<WebhookEvent>;
 /**
  * Verify an HMAC-SHA256 signature using the Web Crypto API.
+ *
+ * Accepts both the canonical Stripe-style format `t=<unix>,v1=<hex>` (signed
+ * over `${ts}.${rawBody}` with replay-window enforcement) and the legacy
+ * `sha256=<hex>` format (signed over `rawBody` only, no timestamp). Use
+ * `options.tolerance` to override the default 300s replay window.
+ *
  * Constant-time comparison to prevent timing attacks.
  */
-declare function verifySignatureAsync(rawBody: string, signature: string, secret: string): Promise<boolean>;
+declare function verifySignatureAsync(rawBody: string, signature: string, secret: string, options?: VerifyOptions): Promise<boolean>;
 
-export { type WebhookEvent, WebhookSignatureVerificationError, constructEventAsync, verifySignatureAsync };
+export { DEFAULT_TOLERANCE_SECONDS, type VerifyOptions, type WebhookEvent, WebhookSignatureVerificationError, constructEventAsync, signPayloadStripeAsync, verifySignatureAsync };

package/dist/webhook/index.js

@@ -1,12 +1,46 @@
 // src/webhook/index.ts
+var DEFAULT_TOLERANCE_SECONDS = 300;
 var WebhookSignatureVerificationError = class extends Error {
   constructor(message) {
     super(message);
     this.name = "WebhookSignatureVerificationError";
   }
 };
-async function constructEventAsync(rawBody, signature, secret) {
-  const valid = await verifySignatureAsync(rawBody, signature, secret);
+function parseStripeHeader(header) {
+  if (!header || header.startsWith("sha256=")) return null;
+  let timestamp = null;
+  const v1 = [];
+  for (const part of header.split(",")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    const key = part.slice(0, eq).trim();
+    const value = part.slice(eq + 1).trim();
+    if (key === "t") {
+      const parsed = Number.parseInt(value, 10);
+      if (Number.isFinite(parsed)) timestamp = parsed;
+    } else if (key === "v1") {
+      v1.push(value);
+    }
+  }
+  if (timestamp === null || v1.length === 0) return null;
+  return { timestamp, v1 };
+}
+async function signPayloadStripeAsync(rawBody, secret) {
+  const ts = Math.floor(Date.now() / 1e3);
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const sigBytes = await crypto.subtle.sign("HMAC", key, encoder.encode(`${ts}.${rawBody}`));
+  const hex = Array.from(new Uint8Array(sigBytes)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `t=${ts},v1=${hex}`;
+}
+async function constructEventAsync(rawBody, signature, secret, options) {
+  const valid = await verifySignatureAsync(rawBody, signature, secret, options);
   if (!valid) {
     throw new WebhookSignatureVerificationError(
       "Webhook signature verification failed. Ensure you are using the raw request body and the correct endpoint secret."
@@ -14,7 +48,7 @@ async function constructEventAsync(rawBody, signature, secret) {
   }
   return JSON.parse(rawBody);
 }
-async function verifySignatureAsync(rawBody, signature, secret) {
+async function hmacHex(material, secret) {
   const encoder = new TextEncoder();
   const key = await crypto.subtle.importKey(
     "raw",
@@ -23,17 +57,37 @@ async function verifySignatureAsync(rawBody, signature, secret) {
     false,
     ["sign"]
   );
-  const sig = await crypto.subtle.sign("HMAC", key, encoder.encode(rawBody));
-  const expected = "sha256=" + Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
-  if (signature.length !== expected.length) return false;
+  const sig = await crypto.subtle.sign("HMAC", key, encoder.encode(material));
+  return Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) return false;
   let result = 0;
-  for (let i = 0; i < signature.length; i++) {
-    result |= signature.charCodeAt(i) ^ expected.charCodeAt(i);
+  for (let i = 0; i < a.length; i++) {
+    result |= a.charCodeAt(i) ^ b.charCodeAt(i);
   }
   return result === 0;
 }
+async function verifySignatureAsync(rawBody, signature, secret, options) {
+  if (typeof signature !== "string" || signature.length === 0) return false;
+  const stripe = parseStripeHeader(signature);
+  if (stripe) {
+    const tolerance = options?.tolerance ?? DEFAULT_TOLERANCE_SECONDS;
+    const now = Math.floor(Date.now() / 1e3);
+    if (Math.abs(now - stripe.timestamp) > tolerance) return false;
+    const expected2 = await hmacHex(`${stripe.timestamp}.${rawBody}`, secret);
+    for (const candidate of stripe.v1) {
+      if (constantTimeEqual(candidate, expected2)) return true;
+    }
+    return false;
+  }
+  const expected = "sha256=" + await hmacHex(rawBody, secret);
+  return constantTimeEqual(signature, expected);
+}
 export {
+  DEFAULT_TOLERANCE_SECONDS,
   WebhookSignatureVerificationError,
   constructEventAsync,
+  signPayloadStripeAsync,
   verifySignatureAsync
 };

package/dist/webhook/node.cjs

@@ -20,14 +20,17 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/webhook/node.ts
 var node_exports = {};
 __export(node_exports, {
+  DEFAULT_TOLERANCE_SECONDS: () => DEFAULT_TOLERANCE_SECONDS,
   WebhookSignatureVerificationError: () => WebhookSignatureVerificationError,
   constructEvent: () => constructEvent,
+  signPayloadStripe: () => signPayloadStripe,
   verifySignature: () => verifySignature
 });
 module.exports = __toCommonJS(node_exports);
 var import_node_crypto = require("crypto");
 
 // src/webhook/index.ts
+var DEFAULT_TOLERANCE_SECONDS = 300;
 var WebhookSignatureVerificationError = class extends Error {
   constructor(message) {
     super(message);
@@ -36,22 +39,67 @@ var WebhookSignatureVerificationError = class extends Error {
 };
 
 // src/webhook/node.ts
-function constructEvent(rawBody, signature, secret) {
-  if (!verifySignature(rawBody, signature, secret)) {
+function parseStripeHeader(header) {
+  if (!header || header.startsWith("sha256=")) return null;
+  let timestamp = null;
+  const v1 = [];
+  for (const part of header.split(",")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    const key = part.slice(0, eq).trim();
+    const value = part.slice(eq + 1).trim();
+    if (key === "t") {
+      const parsed = Number.parseInt(value, 10);
+      if (Number.isFinite(parsed)) timestamp = parsed;
+    } else if (key === "v1") {
+      v1.push(value);
+    }
+  }
+  if (timestamp === null || v1.length === 0) return null;
+  return { timestamp, v1 };
+}
+function constantTimeEqualHex(a, b) {
+  if (a.length !== b.length) return false;
+  try {
+    return (0, import_node_crypto.timingSafeEqual)(Buffer.from(a), Buffer.from(b));
+  } catch {
+    return false;
+  }
+}
+function signPayloadStripe(rawBody, secret) {
+  const ts = Math.floor(Date.now() / 1e3);
+  const sig = (0, import_node_crypto.createHmac)("sha256", secret).update(`${ts}.${rawBody}`).digest("hex");
+  return `t=${ts},v1=${sig}`;
+}
+function constructEvent(rawBody, signature, secret, options) {
+  if (!verifySignature(rawBody, signature, secret, options)) {
     throw new WebhookSignatureVerificationError(
       "Webhook signature verification failed. Ensure you are using the raw request body and the correct endpoint secret."
     );
   }
   return JSON.parse(rawBody);
 }
-function verifySignature(rawBody, signature, secret) {
+function verifySignature(rawBody, signature, secret, options) {
+  if (typeof signature !== "string" || signature.length === 0) return false;
+  const stripe = parseStripeHeader(signature);
+  if (stripe) {
+    const tolerance = options?.tolerance ?? DEFAULT_TOLERANCE_SECONDS;
+    const now = Math.floor(Date.now() / 1e3);
+    if (Math.abs(now - stripe.timestamp) > tolerance) return false;
+    const expected2 = (0, import_node_crypto.createHmac)("sha256", secret).update(`${stripe.timestamp}.${rawBody}`).digest("hex");
+    for (const candidate of stripe.v1) {
+      if (constantTimeEqualHex(candidate, expected2)) return true;
+    }
+    return false;
+  }
   const expected = "sha256=" + (0, import_node_crypto.createHmac)("sha256", secret).update(rawBody).digest("hex");
-  if (signature.length !== expected.length) return false;
-  return (0, import_node_crypto.timingSafeEqual)(Buffer.from(signature), Buffer.from(expected));
+  return constantTimeEqualHex(signature, expected);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DEFAULT_TOLERANCE_SECONDS,
   WebhookSignatureVerificationError,
   constructEvent,
+  signPayloadStripe,
   verifySignature
 });

package/dist/webhook/node.d.cts

@@ -412,11 +412,28 @@ interface WebhookEvent<T extends WebhookEventType = WebhookEventType> {
     data: WebhookEventDataMap[T];
 }
 
+/** Default replay window for Stripe-style signatures: 5 minutes (300s). */
+declare const DEFAULT_TOLERANCE_SECONDS = 300;
+/** Options for signature verification — accepted by both verify and construct calls. */
+interface VerifyOptions {
+    /**
+     * Maximum age (in seconds) of a Stripe-style timestamp before the signature
+     * is rejected as expired. Defaults to {@link DEFAULT_TOLERANCE_SECONDS}.
+     * Ignored for legacy `sha256=<hex>` signatures (which carry no timestamp).
+     */
+    tolerance?: number;
+}
 /** Thrown when webhook signature verification fails. */
 declare class WebhookSignatureVerificationError extends Error {
     constructor(message: string);
 }
 
+/**
+ * Sign a payload in Stripe-style format `t=<unix>,v1=<hex>` (Node-only,
+ * synchronous). Used by the cStar server-side webhook dispatcher and
+ * `cstar listen --forward-to`. The HMAC is computed over `${ts}.${rawBody}`.
+ */
+declare function signPayloadStripe(rawBody: string, secret: string): string;
 /**
  * Verify a webhook signature and parse the event (synchronous, Node.js only).
  *
@@ -427,14 +444,20 @@ declare class WebhookSignatureVerificationError extends Error {
  * @param rawBody - Raw request body as a string (NOT parsed JSON)
  * @param signature - Value of the `X-Signature` header
  * @param secret - Your webhook endpoint's secret (`whsec_*`)
+ * @param options - Optional verifier options (e.g. replay tolerance)
  * @returns Parsed and verified webhook event
  * @throws {WebhookSignatureVerificationError} If verification fails
  */
-declare function constructEvent(rawBody: string, signature: string, secret: string): WebhookEvent;
+declare function constructEvent(rawBody: string, signature: string, secret: string, options?: VerifyOptions): WebhookEvent;
 /**
  * Verify an HMAC-SHA256 signature (synchronous, Node.js only).
- * Uses timing-safe comparison to prevent timing attacks.
+ *
+ * Accepts both the canonical Stripe-style format `t=<unix>,v1=<hex>` (signed
+ * over `${ts}.${rawBody}`, with replay-window enforcement) and the legacy
+ * `sha256=<hex>` format (signed over `rawBody`, no timestamp). Use
+ * `options.tolerance` to override the default 300s replay window. Uses
+ * timing-safe comparison.
  */
-declare function verifySignature(rawBody: string, signature: string, secret: string): boolean;
+declare function verifySignature(rawBody: string, signature: string, secret: string, options?: VerifyOptions): boolean;
 
-export { type WebhookEvent, WebhookSignatureVerificationError, constructEvent, verifySignature };
+export { DEFAULT_TOLERANCE_SECONDS, type VerifyOptions, type WebhookEvent, WebhookSignatureVerificationError, constructEvent, signPayloadStripe, verifySignature };

package/dist/webhook/node.d.ts

@@ -412,11 +412,28 @@ interface WebhookEvent<T extends WebhookEventType = WebhookEventType> {
     data: WebhookEventDataMap[T];
 }
 
+/** Default replay window for Stripe-style signatures: 5 minutes (300s). */
+declare const DEFAULT_TOLERANCE_SECONDS = 300;
+/** Options for signature verification — accepted by both verify and construct calls. */
+interface VerifyOptions {
+    /**
+     * Maximum age (in seconds) of a Stripe-style timestamp before the signature
+     * is rejected as expired. Defaults to {@link DEFAULT_TOLERANCE_SECONDS}.
+     * Ignored for legacy `sha256=<hex>` signatures (which carry no timestamp).
+     */
+    tolerance?: number;
+}
 /** Thrown when webhook signature verification fails. */
 declare class WebhookSignatureVerificationError extends Error {
     constructor(message: string);
 }
 
+/**
+ * Sign a payload in Stripe-style format `t=<unix>,v1=<hex>` (Node-only,
+ * synchronous). Used by the cStar server-side webhook dispatcher and
+ * `cstar listen --forward-to`. The HMAC is computed over `${ts}.${rawBody}`.
+ */
+declare function signPayloadStripe(rawBody: string, secret: string): string;
 /**
  * Verify a webhook signature and parse the event (synchronous, Node.js only).
  *
@@ -427,14 +444,20 @@ declare class WebhookSignatureVerificationError extends Error {
  * @param rawBody - Raw request body as a string (NOT parsed JSON)
  * @param signature - Value of the `X-Signature` header
  * @param secret - Your webhook endpoint's secret (`whsec_*`)
+ * @param options - Optional verifier options (e.g. replay tolerance)
  * @returns Parsed and verified webhook event
  * @throws {WebhookSignatureVerificationError} If verification fails
  */
-declare function constructEvent(rawBody: string, signature: string, secret: string): WebhookEvent;
+declare function constructEvent(rawBody: string, signature: string, secret: string, options?: VerifyOptions): WebhookEvent;
 /**
  * Verify an HMAC-SHA256 signature (synchronous, Node.js only).
- * Uses timing-safe comparison to prevent timing attacks.
+ *
+ * Accepts both the canonical Stripe-style format `t=<unix>,v1=<hex>` (signed
+ * over `${ts}.${rawBody}`, with replay-window enforcement) and the legacy
+ * `sha256=<hex>` format (signed over `rawBody`, no timestamp). Use
+ * `options.tolerance` to override the default 300s replay window. Uses
+ * timing-safe comparison.
  */
-declare function verifySignature(rawBody: string, signature: string, secret: string): boolean;
+declare function verifySignature(rawBody: string, signature: string, secret: string, options?: VerifyOptions): boolean;
 
-export { type WebhookEvent, WebhookSignatureVerificationError, constructEvent, verifySignature };
+export { DEFAULT_TOLERANCE_SECONDS, type VerifyOptions, type WebhookEvent, WebhookSignatureVerificationError, constructEvent, signPayloadStripe, verifySignature };

package/dist/webhook/node.js

@@ -2,6 +2,7 @@
 import { createHmac, timingSafeEqual } from "crypto";
 
 // src/webhook/index.ts
+var DEFAULT_TOLERANCE_SECONDS = 300;
 var WebhookSignatureVerificationError = class extends Error {
   constructor(message) {
     super(message);
@@ -10,21 +11,66 @@ var WebhookSignatureVerificationError = class extends Error {
 };
 
 // src/webhook/node.ts
-function constructEvent(rawBody, signature, secret) {
-  if (!verifySignature(rawBody, signature, secret)) {
+function parseStripeHeader(header) {
+  if (!header || header.startsWith("sha256=")) return null;
+  let timestamp = null;
+  const v1 = [];
+  for (const part of header.split(",")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    const key = part.slice(0, eq).trim();
+    const value = part.slice(eq + 1).trim();
+    if (key === "t") {
+      const parsed = Number.parseInt(value, 10);
+      if (Number.isFinite(parsed)) timestamp = parsed;
+    } else if (key === "v1") {
+      v1.push(value);
+    }
+  }
+  if (timestamp === null || v1.length === 0) return null;
+  return { timestamp, v1 };
+}
+function constantTimeEqualHex(a, b) {
+  if (a.length !== b.length) return false;
+  try {
+    return timingSafeEqual(Buffer.from(a), Buffer.from(b));
+  } catch {
+    return false;
+  }
+}
+function signPayloadStripe(rawBody, secret) {
+  const ts = Math.floor(Date.now() / 1e3);
+  const sig = createHmac("sha256", secret).update(`${ts}.${rawBody}`).digest("hex");
+  return `t=${ts},v1=${sig}`;
+}
+function constructEvent(rawBody, signature, secret, options) {
+  if (!verifySignature(rawBody, signature, secret, options)) {
     throw new WebhookSignatureVerificationError(
       "Webhook signature verification failed. Ensure you are using the raw request body and the correct endpoint secret."
     );
   }
   return JSON.parse(rawBody);
 }
-function verifySignature(rawBody, signature, secret) {
+function verifySignature(rawBody, signature, secret, options) {
+  if (typeof signature !== "string" || signature.length === 0) return false;
+  const stripe = parseStripeHeader(signature);
+  if (stripe) {
+    const tolerance = options?.tolerance ?? DEFAULT_TOLERANCE_SECONDS;
+    const now = Math.floor(Date.now() / 1e3);
+    if (Math.abs(now - stripe.timestamp) > tolerance) return false;
+    const expected2 = createHmac("sha256", secret).update(`${stripe.timestamp}.${rawBody}`).digest("hex");
+    for (const candidate of stripe.v1) {
+      if (constantTimeEqualHex(candidate, expected2)) return true;
+    }
+    return false;
+  }
   const expected = "sha256=" + createHmac("sha256", secret).update(rawBody).digest("hex");
-  if (signature.length !== expected.length) return false;
-  return timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
+  return constantTimeEqualHex(signature, expected);
 }
 export {
+  DEFAULT_TOLERANCE_SECONDS,
   WebhookSignatureVerificationError,
   constructEvent,
+  signPayloadStripe,
   verifySignature
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cstar.help/js",
-	"version": "0.14.0",
+	"version": "0.15.1",
 	"description": "Official TypeScript SDK for the cStar customer support platform",
 	"type": "module",
 	"main": "./dist/index.cjs",