@better-webhook/cli 3.9.0 → 3.10.0

package/dist/core/template-manager.test.js

@@ -0,0 +1,236 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { existsSync, rmSync, mkdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { TemplateManager } from "./template-manager.js";
+describe("TemplateManager", () => {
+    let tempDir;
+    let manager;
+    beforeEach(() => {
+        tempDir = join(tmpdir(), `better-webhook-test-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        manager = new TemplateManager(tempDir);
+    });
+    afterEach(() => {
+        if (existsSync(tempDir)) {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    describe("templateExists", () => {
+        it("should return false when template does not exist", () => {
+            expect(manager.templateExists("non-existent")).toBe(false);
+        });
+        it("should return true when template exists", () => {
+            const template = {
+                url: "http://localhost:3000/webhooks",
+                method: "POST",
+                headers: [],
+                body: { test: true },
+                provider: "github",
+                event: "push",
+            };
+            manager.saveUserTemplate(template, { id: "test-template" });
+            expect(manager.templateExists("test-template")).toBe(true);
+        });
+    });
+    describe("saveUserTemplate", () => {
+        it("should save a template with explicit ID", () => {
+            const template = {
+                url: "http://localhost:3000/webhooks",
+                method: "POST",
+                headers: [{ key: "content-type", value: "application/json" }],
+                body: { action: "created" },
+                provider: "github",
+                event: "push",
+            };
+            const result = manager.saveUserTemplate(template, {
+                id: "my-template",
+                name: "My Template",
+                description: "A test template",
+            });
+            expect(result.id).toBe("my-template");
+            expect(result.filePath).toContain("my-template.json");
+            expect(existsSync(result.filePath)).toBe(true);
+            const saved = JSON.parse(readFileSync(result.filePath, "utf-8"));
+            expect(saved._metadata.id).toBe("my-template");
+            expect(saved._metadata.name).toBe("My Template");
+            expect(saved._metadata.description).toBe("A test template");
+            expect(saved._metadata.source).toBe("capture");
+            expect(saved._metadata.provider).toBe("github");
+            expect(saved._metadata.event).toBe("push");
+        });
+        it("should auto-generate ID from provider and event", () => {
+            const template = {
+                url: "http://localhost:3000/webhooks",
+                method: "POST",
+                headers: [],
+                body: {},
+                provider: "stripe",
+                event: "payment.succeeded",
+            };
+            const result = manager.saveUserTemplate(template);
+            expect(result.id).toBe("stripe-payment.succeeded");
+        });
+        it("should generate unique ID when base ID already exists", () => {
+            const template = {
+                url: "http://localhost:3000/webhooks",
+                method: "POST",
+                headers: [],
+                body: {},
+                provider: "github",
+                event: "push",
+            };
+            const result1 = manager.saveUserTemplate(template);
+            expect(result1.id).toBe("github-push");
+            const result2 = manager.saveUserTemplate(template);
+            expect(result2.id).toBe("github-push-1");
+            const result3 = manager.saveUserTemplate(template);
+            expect(result3.id).toBe("github-push-2");
+        });
+        it("should throw error when template exists and overwrite is false", () => {
+            const template = {
+                url: "http://localhost:3000/webhooks",
+                method: "POST",
+                headers: [],
+                body: {},
+            };
+            manager.saveUserTemplate(template, { id: "existing-template" });
+            expect(() => {
+                manager.saveUserTemplate(template, { id: "existing-template" });
+            }).toThrow('Template with ID "existing-template" already exists');
+        });
+        it("should overwrite when overwrite option is true", () => {
+            const template1 = {
+                url: "http://localhost:3000/webhooks",
+                method: "POST",
+                headers: [],
+                body: { version: 1 },
+            };
+            const template2 = {
+                url: "http://localhost:3000/webhooks",
+                method: "POST",
+                headers: [],
+                body: { version: 2 },
+            };
+            manager.saveUserTemplate(template1, { id: "my-template" });
+            const result = manager.saveUserTemplate(template2, {
+                id: "my-template",
+                overwrite: true,
+            });
+            const saved = JSON.parse(readFileSync(result.filePath, "utf-8"));
+            expect(saved.body.version).toBe(2);
+        });
+        it("should use custom provider as default", () => {
+            const template = {
+                url: "http://localhost:3000/webhooks",
+                method: "POST",
+                headers: [],
+                body: {},
+            };
+            const result = manager.saveUserTemplate(template);
+            expect(result.id).toBe("custom-webhook");
+            const saved = JSON.parse(readFileSync(result.filePath, "utf-8"));
+            expect(saved._metadata.provider).toBe("custom");
+        });
+        it("should use event option over template event", () => {
+            const template = {
+                url: "http://localhost:3000/webhooks",
+                method: "POST",
+                headers: [],
+                body: {},
+                provider: "github",
+                event: "push",
+            };
+            const result = manager.saveUserTemplate(template, {
+                event: "pull_request",
+            });
+            expect(result.id).toBe("github-pull_request");
+            const saved = JSON.parse(readFileSync(result.filePath, "utf-8"));
+            expect(saved._metadata.event).toBe("pull_request");
+        });
+        it("should create provider subdirectory", () => {
+            const template = {
+                url: "http://localhost:3000/webhooks",
+                method: "POST",
+                headers: [],
+                body: {},
+                provider: "slack",
+                event: "message",
+            };
+            const result = manager.saveUserTemplate(template);
+            expect(result.filePath).toContain("slack");
+            expect(existsSync(join(tempDir, "templates", "slack"))).toBe(true);
+        });
+        it("should include createdAt in metadata", () => {
+            const template = {
+                url: "http://localhost:3000/webhooks",
+                method: "POST",
+                headers: [],
+                body: {},
+            };
+            const beforeSave = new Date();
+            const result = manager.saveUserTemplate(template, { id: "test" });
+            const afterSave = new Date();
+            const saved = JSON.parse(readFileSync(result.filePath, "utf-8"));
+            const createdAt = new Date(saved._metadata.createdAt);
+            expect(createdAt.getTime()).toBeGreaterThanOrEqual(beforeSave.getTime());
+            expect(createdAt.getTime()).toBeLessThanOrEqual(afterSave.getTime());
+        });
+    });
+    describe("integration with listLocalTemplates", () => {
+        it("should list saved user templates", () => {
+            const template = {
+                url: "http://localhost:3000/webhooks",
+                method: "POST",
+                headers: [],
+                body: { test: true },
+                provider: "github",
+                event: "push",
+            };
+            manager.saveUserTemplate(template, {
+                id: "user-template",
+                name: "User Template",
+            });
+            const templates = manager.listLocalTemplates();
+            expect(templates).toHaveLength(1);
+            expect(templates[0].id).toBe("user-template");
+            expect(templates[0].metadata.name).toBe("User Template");
+            expect(templates[0].metadata.source).toBe("capture");
+        });
+    });
+    describe("integration with getLocalTemplate", () => {
+        it("should retrieve saved user template by ID", () => {
+            const template = {
+                url: "http://localhost:3000/webhooks",
+                method: "POST",
+                headers: [{ key: "x-custom", value: "test" }],
+                body: { data: "value" },
+                provider: "stripe",
+                event: "invoice.paid",
+            };
+            manager.saveUserTemplate(template, { id: "stripe-test" });
+            const retrieved = manager.getLocalTemplate("stripe-test");
+            expect(retrieved).not.toBeNull();
+            expect(retrieved.id).toBe("stripe-test");
+            expect(retrieved.template.body).toEqual({ data: "value" });
+            expect(retrieved.template.headers).toEqual([
+                { key: "x-custom", value: "test" },
+            ]);
+        });
+    });
+    describe("integration with deleteLocalTemplate", () => {
+        it("should delete saved user template", () => {
+            const template = {
+                url: "http://localhost:3000/webhooks",
+                method: "POST",
+                headers: [],
+                body: {},
+            };
+            manager.saveUserTemplate(template, { id: "to-delete" });
+            expect(manager.templateExists("to-delete")).toBe(true);
+            const deleted = manager.deleteLocalTemplate("to-delete");
+            expect(deleted).toBe(true);
+            expect(manager.templateExists("to-delete")).toBe(false);
+        });
+    });
+});

package/dist/index.cjs

@@ -1764,7 +1764,9 @@ function resolveRuntimePackageVersion(runtimeDir) {
       continue;
     }
     visitedRoots.add(cliPackageRoot);
-    const version = readPackageVersion(import_node_path2.default.join(cliPackageRoot, "package.json"));
+    const version = readPackageVersion(
+      import_node_path2.default.join(cliPackageRoot, "package.json")
+    );
     if (version) {
       return version;
     }
@@ -3156,6 +3158,7 @@ var WebhookProviderSchema = import_zod.z.enum([
   "shopify",
   "twilio",
   "ragie",
+  "recall",
   "sendgrid",
   "slack",
   "discord",
@@ -3849,25 +3852,26 @@ var import_prompts2 = __toESM(require("prompts"), 1);
 var import_undici2 = require("undici");
 
 // src/core/signature.ts
-var import_crypto = require("crypto");
+var import_node_buffer = require("buffer");
+var import_node_crypto = require("crypto");
 function generateStripeSignature(payload, secret, timestamp) {
   const ts = timestamp || Math.floor(Date.now() / 1e3);
   const signedPayload = `${ts}.${payload}`;
-  const signature = (0, import_crypto.createHmac)("sha256", secret).update(signedPayload).digest("hex");
+  const signature = (0, import_node_crypto.createHmac)("sha256", secret).update(signedPayload).digest("hex");
   return {
     header: "Stripe-Signature",
     value: `t=${ts},v1=${signature}`
   };
 }
 function generateGitHubSignature(payload, secret) {
-  const signature = (0, import_crypto.createHmac)("sha256", secret).update(payload).digest("hex");
+  const signature = (0, import_node_crypto.createHmac)("sha256", secret).update(payload).digest("hex");
   return {
     header: "X-Hub-Signature-256",
     value: `sha256=${signature}`
   };
 }
 function generateShopifySignature(payload, secret) {
-  const signature = (0, import_crypto.createHmac)("sha256", secret).update(payload).digest("base64");
+  const signature = (0, import_node_crypto.createHmac)("sha256", secret).update(payload).digest("base64");
   return {
     header: "X-Shopify-Hmac-SHA256",
     value: signature
@@ -3875,7 +3879,7 @@ function generateShopifySignature(payload, secret) {
 }
 function generateTwilioSignature(payload, secret, url) {
   const signatureInput = url + payload;
-  const signature = (0, import_crypto.createHmac)("sha1", secret).update(signatureInput).digest("base64");
+  const signature = (0, import_node_crypto.createHmac)("sha1", secret).update(signatureInput).digest("base64");
   return {
     header: "X-Twilio-Signature",
     value: signature
@@ -3884,14 +3888,14 @@ function generateTwilioSignature(payload, secret, url) {
 function generateSlackSignature(payload, secret, timestamp) {
   const ts = timestamp || Math.floor(Date.now() / 1e3);
   const signatureBaseString = `v0:${ts}:${payload}`;
-  const signature = (0, import_crypto.createHmac)("sha256", secret).update(signatureBaseString).digest("hex");
+  const signature = (0, import_node_crypto.createHmac)("sha256", secret).update(signatureBaseString).digest("hex");
   return {
     header: "X-Slack-Signature",
     value: `v0=${signature}`
   };
 }
 function generateLinearSignature(payload, secret) {
-  const signature = (0, import_crypto.createHmac)("sha256", secret).update(payload).digest("hex");
+  const signature = (0, import_node_crypto.createHmac)("sha256", secret).update(payload).digest("hex");
   return {
     header: "Linear-Signature",
     value: signature
@@ -3901,7 +3905,7 @@ function generateClerkSignature(payload, secret, timestamp, webhookId) {
   const ts = timestamp || Math.floor(Date.now() / 1e3);
   const msgId = webhookId || `msg_${Date.now()}`;
   const signedPayload = `${msgId}.${ts}.${payload}`;
-  const signature = (0, import_crypto.createHmac)("sha256", secret).update(signedPayload).digest("base64");
+  const signature = (0, import_node_crypto.createHmac)("sha256", secret).update(signedPayload).digest("base64");
   return {
     header: "Svix-Signature",
     value: `v1,${signature}`
@@ -3910,19 +3914,38 @@ function generateClerkSignature(payload, secret, timestamp, webhookId) {
 function generateSendGridSignature(payload, secret, timestamp) {
   const ts = timestamp || Math.floor(Date.now() / 1e3);
   const signedPayload = `${ts}${payload}`;
-  const signature = (0, import_crypto.createHmac)("sha256", secret).update(signedPayload).digest("base64");
+  const signature = (0, import_node_crypto.createHmac)("sha256", secret).update(signedPayload).digest("base64");
   return {
     header: "X-Twilio-Email-Event-Webhook-Signature",
     value: signature
   };
 }
 function generateRagieSignature(payload, secret) {
-  const signature = (0, import_crypto.createHmac)("sha256", secret).update(payload).digest("hex");
+  const signature = (0, import_node_crypto.createHmac)("sha256", secret).update(payload).digest("hex");
   return {
     header: "X-Signature",
     value: signature
   };
 }
+function generateRecallSignature(payload, secret, timestamp, webhookId) {
+  if (!secret.startsWith("whsec_")) {
+    throw new Error(
+      "Recall signature generation requires a secret with the whsec_ prefix"
+    );
+  }
+  const ts = timestamp ?? Math.floor(Date.now() / 1e3);
+  const msgId = webhookId ?? `msg_${Date.now()}`;
+  const key = import_node_buffer.Buffer.from(secret.slice("whsec_".length), "base64");
+  if (key.length === 0) {
+    throw new Error("Recall signing secret is invalid");
+  }
+  const signedPayload = `${msgId}.${ts}.${payload}`;
+  const signature = (0, import_node_crypto.createHmac)("sha256", key).update(signedPayload).digest("base64");
+  return {
+    header: "Webhook-Signature",
+    value: `v1,${signature}`
+  };
+}
 function generateSignature(provider, payload, secret, options) {
   const timestamp = options?.timestamp;
   switch (provider) {
@@ -3952,6 +3975,13 @@ function generateSignature(provider, payload, secret, options) {
       return generateSendGridSignature(payload, secret, timestamp);
     case "ragie":
       return generateRagieSignature(payload, secret);
+    case "recall":
+      return generateRecallSignature(
+        payload,
+        secret,
+        timestamp,
+        options?.webhookId
+      );
     case "discord":
     case "custom":
     default:
@@ -4040,6 +4070,13 @@ function getProviderHeaders(provider, options) {
         // Event type + nonce are included in the JSON body envelope.
       );
       break;
+    case "recall":
+      headers.push(
+        { key: "Content-Type", value: "application/json" },
+        { key: "Webhook-Id", value: options?.webhookId || `msg_${Date.now()}` },
+        { key: "Webhook-Timestamp", value: String(timestamp) }
+      );
+      break;
     default:
       headers.push({ key: "Content-Type", value: "application/json" });
   }
@@ -4078,8 +4115,14 @@ async function executeWebhook(options) {
     }
   }
   if (options.secret && options.provider && bodyStr) {
+    const timestampHeader = headers["Webhook-Timestamp"] || headers["webhook-timestamp"] || headers["Svix-Timestamp"] || headers["svix-timestamp"] || headers["X-Slack-Request-Timestamp"] || headers["x-slack-request-timestamp"] || headers["X-Twilio-Email-Event-Webhook-Timestamp"] || headers["x-twilio-email-event-webhook-timestamp"];
+    const parsedTimestamp = timestampHeader ? Number.parseInt(timestampHeader, 10) : void 0;
+    const timestamp = Number.isFinite(parsedTimestamp) ? parsedTimestamp : void 0;
+    const webhookId = headers["Webhook-Id"] || headers["webhook-id"] || headers["Svix-Id"] || headers["svix-id"] || headers["X-GitHub-Delivery"] || headers["x-github-delivery"];
     const sig = generateSignature(options.provider, bodyStr, options.secret, {
-      url: options.url
+      url: options.url,
+      timestamp,
+      webhookId
     });
     if (sig) {
       headers[sig.header] = sig.value;
@@ -4194,6 +4237,7 @@ function getSecretEnvVarName(provider) {
     shopify: "SHOPIFY_WEBHOOK_SECRET",
     twilio: "TWILIO_WEBHOOK_SECRET",
     ragie: "RAGIE_WEBHOOK_SECRET",
+    recall: "RECALL_WEBHOOK_SECRET",
     slack: "SLACK_WEBHOOK_SECRET",
     linear: "LINEAR_WEBHOOK_SECRET",
     clerk: "CLERK_WEBHOOK_SECRET",
@@ -4379,7 +4423,7 @@ var import_http = require("http");
 var import_ws = require("ws");
 var import_fs2 = require("fs");
 var import_path2 = require("path");
-var import_crypto2 = require("crypto");
+var import_crypto = require("crypto");
 var import_os2 = require("os");
 var CaptureServer = class {
   server = null;
@@ -4491,7 +4535,7 @@ var CaptureServer = class {
       return;
     }
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const id = (0, import_crypto2.randomUUID)();
+    const id = (0, import_crypto.randomUUID)();
     const url = req.url || "/";
     const hostHeader = req.headers.host;
     const hostValue = typeof hostHeader === "string" ? hostHeader : "";
@@ -4631,6 +4675,12 @@ var CaptureServer = class {
         return "ragie";
       }
     }
+    if (this.hasStandardWebhookHeaders(headers)) {
+      const recallUserAgent = this.headerIncludes(headers["user-agent"], "recall");
+      if (recallUserAgent || this.hasRecallStandardWebhookShape(body)) {
+        return "recall";
+      }
+    }
     if (headers["x-shopify-hmac-sha256"] || headers["x-shopify-topic"]) {
       return "shopify";
     }
@@ -4650,6 +4700,9 @@ var CaptureServer = class {
       return "linear";
     }
     if (headers["svix-signature"]) {
+      if (body && typeof body === "object" && "event" in body && typeof body.event === "string" && body.event.startsWith("bot.")) {
+        return "recall";
+      }
       return "clerk";
     }
     return void 0;
@@ -4665,6 +4718,57 @@ var CaptureServer = class {
       }
     }
   }
+  hasStandardWebhookHeaders(headers) {
+    return Boolean(
+      headers["webhook-signature"] || headers["webhook-id"] && headers["webhook-timestamp"]
+    );
+  }
+  hasRecallStandardWebhookShape(body) {
+    if (!body || typeof body !== "object") {
+      return false;
+    }
+    const payload = body;
+    if (this.hasRecallEventPrefix(payload.event)) {
+      return true;
+    }
+    if (this.hasRecallResourceCombination(payload)) {
+      return true;
+    }
+    const nestedData = payload.data;
+    if (nestedData && typeof nestedData === "object") {
+      return this.hasRecallResourceCombination(
+        nestedData
+      );
+    }
+    return false;
+  }
+  hasRecallEventPrefix(event) {
+    if (typeof event !== "string") {
+      return false;
+    }
+    return ["bot.", "transcript.", "participant_events."].some(
+      (prefix) => event.startsWith(prefix)
+    );
+  }
+  hasRecallResourceCombination(payload) {
+    const hasRealtimeEndpoint = "realtime_endpoint" in payload;
+    const hasRecording = "recording" in payload;
+    const hasParticipantEvents = "participant_events" in payload;
+    const hasTranscript = "transcript" in payload;
+    return hasRealtimeEndpoint && hasRecording && (hasParticipantEvents || hasTranscript);
+  }
+  headerIncludes(headerValue, searchText) {
+    const normalizedSearchText = searchText.toLowerCase();
+    if (typeof headerValue === "string") {
+      return headerValue.toLowerCase().includes(normalizedSearchText);
+    }
+    if (Array.isArray(headerValue)) {
+      return headerValue.some(
+        (value) => value.toLowerCase().includes(normalizedSearchText)
+      );
+    }
+    return false;
+  }
   /**
    * Send message to a specific client
    */
@@ -4866,6 +4970,7 @@ var ReplayEngine = class {
       "x-twilio-signature",
       "x-slack-signature",
       "svix-signature",
+      "webhook-signature",
       "linear-signature"
     ];
     const headers = [];
@@ -4937,10 +5042,19 @@ var ReplayEngine = class {
     }
     if (capture2.provider === "ragie" && capture2.body) {
       const body = capture2.body;
+      if (typeof body.type === "string") {
+        return body.type;
+      }
       if (typeof body.event_type === "string") {
         return body.event_type;
       }
     }
+    if (capture2.provider === "recall" && capture2.body) {
+      const body = capture2.body;
+      if (typeof body.event === "string") {
+        return body.event;
+      }
+    }
     const shopifyTopic = headers["x-shopify-topic"];
     if (shopifyTopic) {
       return Array.isArray(shopifyTopic) ? shopifyTopic[0] : shopifyTopic;
@@ -5527,6 +5641,7 @@ function getSecretEnvVarName2(provider) {
     shopify: "SHOPIFY_WEBHOOK_SECRET",
     twilio: "TWILIO_WEBHOOK_SECRET",
     ragie: "RAGIE_WEBHOOK_SECRET",
+    recall: "RECALL_WEBHOOK_SECRET",
     slack: "SLACK_WEBHOOK_SECRET",
     linear: "LINEAR_WEBHOOK_SECRET",
     clerk: "CLERK_WEBHOOK_SECRET",
@@ -6104,13 +6219,13 @@ var dashboard = new import_commander6.Command().name("dashboard").description("S
       process.exitCode = 1;
       return;
     }
+    const capturePort = Number.parseInt(String(options.capturePort), 10);
+    if (!Number.isFinite(capturePort) || capturePort < 0 || capturePort > 65535) {
+      console.error(source_default.red("Invalid capture port number"));
+      process.exitCode = 1;
+      return;
+    }
     try {
-      const capturePort = Number.parseInt(String(options.capturePort), 10);
-      if (!Number.isFinite(capturePort) || capturePort < 0 || capturePort > 65535) {
-        console.error(source_default.red("Invalid capture port number"));
-        process.exitCode = 1;
-        return;
-      }
       const verbose = Boolean(options.verbose || options.debug);
       const { url, server, capture: capture2 } = await startDashboardServer({
         host: options.host,