@better-webhook/cli 3.4.4 → 3.6.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { Command as Command7 } from "commander";
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/commands/templates.ts
@@ -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,10 +2679,141 @@ 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;
 }
 
 // src/core/dashboard-server.ts
+function isStandaloneBinary() {
+  if (typeof STANDALONE_BINARY !== "undefined" && STANDALONE_BINARY) {
+    return true;
+  }
+  if (typeof globalThis.embeddedDashboardFiles !== "undefined" && globalThis.embeddedDashboardFiles) {
+    return true;
+  }
+  return false;
+}
+function getMimeType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const mimeTypes = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "application/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".ico": "image/x-icon",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf": "font/ttf",
+    ".eot": "application/vnd.ms-fontobject"
+  };
+  return mimeTypes[ext] || "application/octet-stream";
+}
+function createEmbeddedDashboardMiddleware() {
+  const filePathMap = /* @__PURE__ */ new Map();
+  let indexHtmlPath = null;
+  if (typeof globalThis.embeddedDashboardFiles !== "undefined") {
+    for (const [key, filePath] of Object.entries(
+      globalThis.embeddedDashboardFiles
+    )) {
+      const servePath = "/" + key.replace(/^dashboard\//, "");
+      filePathMap.set(servePath, filePath);
+      if (servePath === "/index.html") {
+        indexHtmlPath = filePath;
+      }
+    }
+  }
+  const staticMiddleware = async (req, res, next) => {
+    if (!Bun) {
+      return next();
+    }
+    const requestPath = req.path === "/" ? "/index.html" : req.path;
+    const filePath = filePathMap.get(requestPath);
+    if (filePath) {
+      try {
+        const file = Bun.file(filePath);
+        const content = await file.arrayBuffer();
+        res.setHeader("Content-Type", getMimeType(requestPath));
+        res.setHeader("Content-Length", content.byteLength);
+        res.send(Buffer.from(content));
+      } catch (err) {
+        console.error(`Failed to serve embedded file ${requestPath}:`, err);
+        next();
+      }
+    } else {
+      next();
+    }
+  };
+  const spaFallback = async (req, res, next) => {
+    if (req.path.startsWith("/api") || req.path === "/health") {
+      return next();
+    }
+    if (!Bun || !indexHtmlPath) {
+      return next();
+    }
+    try {
+      const file = Bun.file(indexHtmlPath);
+      const content = await file.arrayBuffer();
+      res.setHeader("Content-Type", "text/html; charset=utf-8");
+      res.setHeader("Content-Length", content.byteLength);
+      res.send(Buffer.from(content));
+    } catch {
+      next();
+    }
+  };
+  return { staticMiddleware, spaFallback };
+}
 function resolveDashboardDistDir(runtimeDir) {
   const candidates = [
     // Bundled CLI: dist/index.js -> dist/dashboard
@@ -2469,18 +2867,24 @@ async function startDashboardServer(options = {}) {
   );
   const host = options.host || "localhost";
   const port = options.port ?? 4e3;
-  const runtimeDir = typeof __dirname !== "undefined" ? (
-    // eslint-disable-next-line no-undef
-    __dirname
-  ) : path.dirname(fileURLToPath(import.meta.url));
-  const { distDir: dashboardDistDir, indexHtml: dashboardIndexHtml } = resolveDashboardDistDir(runtimeDir);
-  app.use(express2.static(dashboardDistDir));
-  app.get("*", (req, res, next) => {
-    if (req.path.startsWith("/api") || req.path === "/health") return next();
-    res.sendFile(dashboardIndexHtml, (err) => {
-      if (err) next();
+  if (isStandaloneBinary()) {
+    const { staticMiddleware, spaFallback } = createEmbeddedDashboardMiddleware();
+    app.use(staticMiddleware);
+    app.get("*", spaFallback);
+  } else {
+    const runtimeDir = typeof __dirname !== "undefined" ? (
+      // eslint-disable-next-line no-undef
+      __dirname
+    ) : path.dirname(fileURLToPath(import.meta.url));
+    const { distDir: dashboardDistDir, indexHtml: dashboardIndexHtml } = resolveDashboardDistDir(runtimeDir);
+    app.use(express2.static(dashboardDistDir));
+    app.get("*", (req, res, next) => {
+      if (req.path.startsWith("/api") || req.path === "/health") return next();
+      res.sendFile(dashboardIndexHtml, (err) => {
+        if (err) next();
+      });
     });
-  });
+  }
   const server = createServer2(app);
   const wss = new WebSocketServer2({ server, path: "/ws" });
   wss.on("connection", async (ws) => {
@@ -2606,14 +3010,24 @@ var dashboard = new Command6().name("dashboard").description("Start the local da
 });
 
 // src/index.ts
-var packageJsonPath = fileURLToPath2(
-  new URL("../package.json", import.meta.url)
-);
-var packageJson = JSON.parse(
-  readFileSync4(packageJsonPath, { encoding: "utf8" })
-);
+function getVersion() {
+  if (typeof CLI_VERSION !== "undefined") {
+    return CLI_VERSION;
+  }
+  try {
+    const packageJsonPath = fileURLToPath2(
+      new URL("../package.json", import.meta.url)
+    );
+    const packageJson = JSON.parse(
+      readFileSync5(packageJsonPath, { encoding: "utf8" })
+    );
+    return packageJson.version;
+  } catch {
+    return "0.0.0-unknown";
+  }
+}
 var program = new Command7().name("better-webhook").description(
   "Modern CLI for developing, capturing, and replaying webhooks locally"
-).version(packageJson.version);
+).version(getVersion());
 program.addCommand(templates).addCommand(run).addCommand(capture).addCommand(captures).addCommand(replay).addCommand(dashboard);
 program.parseAsync(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@better-webhook/cli",
-  "version": "3.4.4",
+  "version": "3.6.0",
   "description": "Modern CLI for developing, capturing, and replaying webhooks locally with dashboard UI.",
   "type": "module",
   "bin": {
@@ -55,11 +55,12 @@
     "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"
   },
   "devDependencies": {
+    "@types/bun": "^1.2.18",
     "@types/express": "^4.17.21",
     "@types/node": "^24.3.1",
     "@types/prompts": "^2.4.9",
@@ -72,8 +73,11 @@
   "scripts": {
     "build:cli": "tsup --format cjs,esm --dts && node ./scripts/copy-dashboard.mjs",
     "build": "pnpm --filter @better-webhook/dashboard build && pnpm run build:cli",
+    "build:binary": "bun ./scripts/build-binary.ts",
+    "build:binary:all": "bun ./scripts/build-binary.ts --all",
     "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;