@better-webhook/cli 3.4.4 → 3.5.0

package/dist/index.js

@@ -109,6 +109,12 @@ var ConfigSchema = z.object({
 // src/core/template-manager.ts
 var GITHUB_RAW_BASE = "https://raw.githubusercontent.com/endalk200/better-webhook/main";
 var TEMPLATES_INDEX_URL = `${GITHUB_RAW_BASE}/templates/templates.json`;
+var TEMPLATE_ID_PATTERN = /^[a-z0-9][a-z0-9._-]*$/i;
+function isValidTemplateId(id) {
+  if (!id || id.length > 128) return false;
+  if (id.includes("/") || id.includes("\\") || id.includes("..")) return false;
+  return TEMPLATE_ID_PATTERN.test(id);
+}
 var TemplateManager = class {
   baseDir;
   templatesDir;
@@ -362,6 +368,76 @@ var TemplateManager = class {
     }
     return deleted;
   }
+  /**
+   * Check if a template with the given ID already exists locally
+   */
+  templateExists(templateId) {
+    return this.getLocalTemplate(templateId) !== null;
+  }
+  /**
+   * Generate a unique template ID from provider and event
+   */
+  generateTemplateId(provider, event) {
+    const providerPart = provider || "custom";
+    const eventPart = event || "webhook";
+    const baseId = `${providerPart}-${eventPart}`.toLowerCase().replace(/\s+/g, "-");
+    if (!this.templateExists(baseId)) {
+      return baseId;
+    }
+    let counter = 1;
+    while (this.templateExists(`${baseId}-${counter}`)) {
+      counter++;
+    }
+    return `${baseId}-${counter}`;
+  }
+  /**
+   * Save a user-created template from a captured webhook
+   */
+  saveUserTemplate(template, options = {}) {
+    const provider = template.provider || "custom";
+    const event = options.event || template.event || "webhook";
+    const templateId = options.id || this.generateTemplateId(provider, event);
+    const name = options.name || templateId;
+    const description = options.description || template.description;
+    if (!isValidTemplateId(templateId)) {
+      throw new Error(
+        `Invalid template ID "${templateId}". IDs must start with alphanumeric, contain only letters, numbers, dots, underscores, and hyphens.`
+      );
+    }
+    if (!options.overwrite && this.templateExists(templateId)) {
+      throw new Error(
+        `Template with ID "${templateId}" already exists. Use --overwrite to replace it.`
+      );
+    }
+    const providerDir = join(this.templatesDir, provider);
+    if (!existsSync(providerDir)) {
+      mkdirSync(providerDir, { recursive: true });
+    }
+    const metadata = {
+      id: templateId,
+      name,
+      provider,
+      event,
+      file: `${provider}/${templateId}.json`,
+      description,
+      source: "capture",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const saveData = {
+      ...template,
+      provider,
+      event,
+      description,
+      _metadata: metadata
+    };
+    const filePath = join(providerDir, `${templateId}.json`);
+    writeFileSync(filePath, JSON.stringify(saveData, null, 2));
+    return {
+      id: templateId,
+      filePath,
+      template: saveData
+    };
+  }
 };
 var instance = null;
 function getTemplateManager(baseDir) {
@@ -1538,6 +1614,7 @@ var capture = new Command3().name("capture").description("Start a server to capt
 import { Command as Command4 } from "commander";
 import chalk4 from "chalk";
 import prompts3 from "prompts";
+import { homedir as homedir4 } from "os";
 
 // src/core/replay-engine.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync3, unlinkSync as unlinkSync3 } from "fs";
@@ -1671,15 +1748,93 @@ var ReplayEngine = class {
         body = capture2.rawBody;
       }
     }
+    const event = options?.event || this.detectEvent(capture2);
     return {
       url: options?.url || `http://localhost:3000${capture2.path}`,
       method: capture2.method,
       headers,
       body,
       provider: capture2.provider,
+      event,
       description: `Captured ${capture2.provider || "webhook"} at ${capture2.timestamp}`
     };
   }
+  /**
+   * Detect event type from captured webhook headers/body
+   */
+  detectEvent(capture2) {
+    const headers = capture2.headers;
+    const githubEvent = headers["x-github-event"];
+    if (githubEvent) {
+      return Array.isArray(githubEvent) ? githubEvent[0] : githubEvent;
+    }
+    if (capture2.provider === "stripe" && capture2.body) {
+      const body = capture2.body;
+      if (typeof body.type === "string") {
+        return body.type;
+      }
+    }
+    if (capture2.provider === "slack" && capture2.body) {
+      const body = capture2.body;
+      if (typeof body.type === "string") {
+        return body.type;
+      }
+      const event = body.event;
+      if (event && typeof event.type === "string") {
+        return event.type;
+      }
+    }
+    if (capture2.provider === "linear" && capture2.body) {
+      const body = capture2.body;
+      if (typeof body.type === "string") {
+        return body.type;
+      }
+    }
+    if (capture2.provider === "clerk" && capture2.body) {
+      const body = capture2.body;
+      if (typeof body.type === "string") {
+        return body.type;
+      }
+    }
+    if (capture2.provider === "ragie" && capture2.body) {
+      const body = capture2.body;
+      if (typeof body.event_type === "string") {
+        return body.event_type;
+      }
+    }
+    const shopifyTopic = headers["x-shopify-topic"];
+    if (shopifyTopic) {
+      return Array.isArray(shopifyTopic) ? shopifyTopic[0] : shopifyTopic;
+    }
+    if (capture2.provider === "sendgrid" && Array.isArray(capture2.body)) {
+      const firstEvent = capture2.body[0];
+      if (firstEvent && typeof firstEvent.event === "string") {
+        return firstEvent.event;
+      }
+    }
+    if (capture2.provider === "discord" && capture2.body) {
+      const body = capture2.body;
+      if (typeof body.type === "number") {
+        return `type_${body.type}`;
+      }
+    }
+    if (capture2.body && typeof capture2.body === "object") {
+      const body = capture2.body;
+      if (typeof body.type === "string") {
+        return body.type;
+      }
+      if (typeof body.event_type === "string") {
+        return body.event_type;
+      }
+      if (typeof body.event === "string") {
+        return body.event;
+      }
+      if (typeof body.action === "string") {
+        return body.action;
+      }
+    }
+    return void 0;
+  }
   /**
    * Get a summary of a capture
    */
@@ -1768,6 +1923,13 @@ function getReplayEngine(capturesDir) {
 }
 
 // src/commands/captures.ts
+function toRelativePath(absolutePath) {
+  const home = homedir4();
+  if (absolutePath.startsWith(home)) {
+    return "~" + absolutePath.slice(home.length);
+  }
+  return absolutePath;
+}
 var listCommand2 = new Command4().name("list").alias("ls").description("List captured webhooks").option("-l, --limit <limit>", "Maximum number of captures to show", "20").option("-p, --provider <provider>", "Filter by provider").action((options) => {
   const limit = parseInt(options.limit, 10);
   if (isNaN(limit) || limit <= 0) {
@@ -1976,7 +2138,92 @@ var cleanCommand2 = new Command4().name("clean").alias("remove-all").description
   console.log(chalk4.gray(`  Storage: ${engine.getCapturesDir()}
 `));
 });
-var captures = new Command4().name("captures").alias("c").description("Manage captured webhooks").addCommand(listCommand2).addCommand(showCommand).addCommand(searchCommand2).addCommand(deleteCommand).addCommand(cleanCommand2);
+var saveAsTemplateCommand = new Command4().name("save-as-template").alias("sat").argument("<captureId>", "Capture ID or partial ID").description("Save a captured webhook as a reusable template").option("--id <id>", "Template ID (auto-generated if not provided)").option("--name <name>", "Template display name").option("--event <event>", "Event type (auto-detected if not provided)").option("--description <description>", "Template description").option("--url <url>", "Default target URL for the template").option("--overwrite", "Overwrite existing template with same ID").action(
+  async (captureId, options) => {
+    const engine = getReplayEngine();
+    const templateManager = getTemplateManager();
+    const captureFile = engine.getCapture(captureId);
+    if (!captureFile) {
+      console.log(chalk4.red(`
+\u274C Capture not found: ${captureId}
+`));
+      process.exitCode = 1;
+      return;
+    }
+    const { capture: capture2 } = captureFile;
+    console.log(chalk4.bold("\n\u{1F4CB} Capture to save as template:\n"));
+    console.log(`    ${chalk4.white(capture2.id.slice(0, 8))}`);
+    console.log(chalk4.gray(`    ${capture2.method} ${capture2.path}`));
+    if (capture2.provider) {
+      console.log(chalk4.gray(`    Provider: ${capture2.provider}`));
+    }
+    console.log();
+    const template = engine.captureToTemplate(captureId, {
+      url: options.url,
+      event: options.event
+    });
+    let templateId = options.id;
+    if (!templateId) {
+      const suggestedId = `${capture2.provider || "custom"}-${template.event || "webhook"}`.toLowerCase().replace(/\s+/g, "-");
+      const response = await prompts3({
+        type: "text",
+        name: "templateId",
+        message: "Template ID:",
+        initial: suggestedId,
+        validate: (value) => value.trim().length > 0 || "Template ID is required"
+      });
+      if (!response.templateId) {
+        console.log(chalk4.yellow("Cancelled"));
+        return;
+      }
+      templateId = response.templateId;
+    }
+    if (!options.overwrite && templateId && templateManager.templateExists(templateId)) {
+      const response = await prompts3({
+        type: "confirm",
+        name: "overwrite",
+        message: `Template "${templateId}" already exists. Overwrite?`,
+        initial: false
+      });
+      if (!response.overwrite) {
+        console.log(chalk4.yellow("Cancelled"));
+        return;
+      }
+      options.overwrite = true;
+    }
+    try {
+      const result = templateManager.saveUserTemplate(template, {
+        id: templateId,
+        name: options.name,
+        event: options.event || template.event,
+        description: options.description,
+        overwrite: options.overwrite
+      });
+      console.log(chalk4.green(`
+\u2713 Saved template: ${result.id}`));
+      console.log(chalk4.gray(`  File: ${toRelativePath(result.filePath)}`));
+      console.log(chalk4.gray(`  Provider: ${template.provider || "custom"}`));
+      if (template.event) {
+        console.log(chalk4.gray(`  Event: ${template.event}`));
+      }
+      console.log();
+      console.log(chalk4.gray("  Run it with:"));
+      console.log(
+        chalk4.cyan(
+          `    better-webhook run ${result.id} --url http://localhost:3000/webhooks
+`
+        )
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Failed to save template";
+      console.log(chalk4.red(`
+\u274C ${message}
+`));
+      process.exitCode = 1;
+    }
+  }
+);
+var captures = new Command4().name("captures").alias("c").description("Manage captured webhooks").addCommand(listCommand2).addCommand(showCommand).addCommand(searchCommand2).addCommand(deleteCommand).addCommand(cleanCommand2).addCommand(saveAsTemplateCommand);
 
 // src/commands/replay.ts
 import { Command as Command5 } from "commander";
@@ -2163,12 +2410,28 @@ var ReplayBodySchema = z2.object({
 var TemplateDownloadBodySchema = z2.object({
   id: z2.string().min(1)
 });
+var TemplateIdSchema = z2.string().regex(
+  /^[a-z0-9][a-z0-9._-]*$/i,
+  "ID must start with alphanumeric and contain only letters, numbers, dots, underscores, and hyphens"
+).max(128, "ID must be 128 characters or less").refine(
+  (val) => !val.includes("/") && !val.includes("\\") && !val.includes(".."),
+  "ID cannot contain path separators or parent directory references"
+);
 var RunTemplateBodySchema = z2.object({
   templateId: z2.string().min(1),
   url: z2.string().min(1),
   secret: z2.string().optional(),
   headers: z2.array(HeaderEntrySchema).optional()
 });
+var SaveAsTemplateBodySchema = z2.object({
+  captureId: z2.string().min(1),
+  id: TemplateIdSchema.optional(),
+  name: z2.string().optional(),
+  event: z2.string().optional(),
+  description: z2.string().optional(),
+  url: z2.string().optional(),
+  overwrite: z2.boolean().optional()
+});
 function createDashboardApiRouter(options = {}) {
   const router = express.Router();
   const replayEngine = new ReplayEngine(options.capturesDir);
@@ -2184,22 +2447,26 @@ function createDashboardApiRouter(options = {}) {
   };
   const broadcastTemplates = async () => {
     if (!broadcast) return;
-    const local = templateManager.listLocalTemplates();
-    let remote = [];
     try {
-      const index = await templateManager.fetchRemoteIndex(false);
-      const localIds = new Set(local.map((t) => t.id));
-      remote = index.templates.map((metadata) => ({
-        metadata,
-        isDownloaded: localIds.has(metadata.id)
-      }));
-    } catch {
-      remote = [];
+      const local = templateManager.listLocalTemplates();
+      let remote = [];
+      try {
+        const index = await templateManager.fetchRemoteIndex(false);
+        const localIds = new Set(local.map((t) => t.id));
+        remote = index.templates.map((metadata) => ({
+          metadata,
+          isDownloaded: localIds.has(metadata.id)
+        }));
+      } catch {
+        remote = [];
+      }
+      broadcast({
+        type: "templates_updated",
+        payload: { local, remote }
+      });
+    } catch (error) {
+      console.error("[dashboard-api] Failed to broadcast templates:", error);
     }
-    broadcast({
-      type: "templates_updated",
-      payload: { local, remote }
-    });
   };
   router.get("/captures", (req, res) => {
     const limitRaw = typeof req.query.limit === "string" ? req.query.limit : "";
@@ -2412,6 +2679,54 @@ function createDashboardApiRouter(options = {}) {
       return jsonError(res, 400, error?.message || "Run failed");
     }
   });
+  router.post(
+    "/templates/from-capture",
+    express.json({ limit: "5mb" }),
+    async (req, res) => {
+      const parsed = SaveAsTemplateBodySchema.safeParse(req.body);
+      if (!parsed.success) {
+        return jsonError(
+          res,
+          400,
+          parsed.error.issues[0]?.message || "Invalid body"
+        );
+      }
+      const { captureId, id, name, event, description, url, overwrite } = parsed.data;
+      if (url !== void 0) {
+        try {
+          new URL(url);
+        } catch {
+          return jsonError(res, 400, "Invalid url");
+        }
+      }
+      const captureFile = replayEngine.getCapture(captureId);
+      if (!captureFile) {
+        return jsonError(res, 404, "Capture not found");
+      }
+      const template = replayEngine.captureToTemplate(captureId, {
+        url,
+        event
+      });
+      try {
+        const result = templateManager.saveUserTemplate(template, {
+          id,
+          name,
+          event: event || template.event,
+          description,
+          overwrite
+        });
+        void broadcastTemplates();
+        return res.json({
+          success: true,
+          id: result.id,
+          filePath: result.filePath,
+          template: result.template
+        });
+      } catch (error) {
+        return jsonError(res, 400, error?.message || "Failed to save template");
+      }
+    }
+  );
   return router;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@better-webhook/cli",
-  "version": "3.4.4",
+  "version": "3.5.0",
   "description": "Modern CLI for developing, capturing, and replaying webhooks locally with dashboard UI.",
   "type": "module",
   "bin": {
@@ -55,7 +55,7 @@
     "express": "^4.21.0",
     "ora": "^8.1.0",
     "prompts": "^2.4.2",
-    "undici": "^7.16.0",
+    "undici": "^7.18.2",
     "ws": "^8.18.0",
     "zod": "^3.23.8"
   },
@@ -74,6 +74,7 @@
     "build": "pnpm --filter @better-webhook/dashboard build && pnpm run build:cli",
     "dev": "tsup --watch",
     "start": "tsx src/index.ts",
-    "lint": "tsc"
+    "lint": "tsc",
+    "test": "vitest run"
   }
 }

package/dist/commands/capture.d.ts

@@ -1,2 +0,0 @@
-import { Command } from "commander";
-export declare const capture: Command;

package/dist/commands/capture.js

@@ -1,30 +0,0 @@
-import { Command } from "commander";
-import chalk from "chalk";
-import { CaptureServer } from "../core/capture-server.js";
-export const capture = new Command()
-    .name("capture")
-    .description("Start a server to capture incoming webhooks")
-    .option("-p, --port <port>", "Port to listen on", "3001")
-    .option("-h, --host <host>", "Host to bind to", "0.0.0.0")
-    .action(async (options) => {
-    const port = parseInt(options.port, 10);
-    if (isNaN(port) || port < 0 || port > 65535) {
-        console.error(chalk.red("Invalid port number"));
-        process.exitCode = 1;
-        return;
-    }
-    const server = new CaptureServer();
-    try {
-        await server.start(port, options.host);
-        const shutdown = async () => {
-            await server.stop();
-            process.exit(0);
-        };
-        process.on("SIGINT", shutdown);
-        process.on("SIGTERM", shutdown);
-    }
-    catch (error) {
-        console.error(chalk.red(`Failed to start server: ${error.message}`));
-        process.exitCode = 1;
-    }
-});

package/dist/commands/captures.d.ts

@@ -1,2 +0,0 @@
-import { Command } from "commander";
-export declare const captures: Command;