@better-webhook/cli 0.3.1 → 3.1.0

package/dist/index.js

@@ -1,20 +1,31 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command4 } from "commander";
+import { Command as Command7 } from "commander";
 
-// src/commands/webhooks.ts
+// src/commands/templates.ts
 import { Command } from "commander";
-import { join as join2, resolve as resolve2, basename } from "path";
-import { statSync as statSync2 } from "fs";
+import ora from "ora";
+import prompts from "prompts";
+import chalk from "chalk";
 
-// src/utils/index.ts
-import { readdirSync, readFileSync, statSync } from "fs";
-import { join, resolve, extname } from "path";
+// src/core/template-manager.ts
+import { request } from "undici";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmdirSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { join, basename } from "path";
+import { homedir } from "os";
 
-// src/schema.ts
+// src/types/index.ts
 import { z } from "zod";
-var httpMethodSchema = z.enum([
+var HttpMethodSchema = z.enum([
   "GET",
   "POST",
   "PUT",
@@ -23,459 +34,1270 @@ var httpMethodSchema = z.enum([
   "HEAD",
   "OPTIONS"
 ]);
-var headerEntrySchema = z.object({
-  key: z.string().min(1, "Header key cannot be empty").regex(/^[A-Za-z0-9-]+$/, {
-    message: "Header key must contain only alphanumerics and -"
-  }),
-  value: z.string().min(1, "Header value cannot be empty")
+var HeaderEntrySchema = z.object({
+  key: z.string().min(1),
+  value: z.string()
+});
+var WebhookProviderSchema = z.enum([
+  "stripe",
+  "github",
+  "shopify",
+  "twilio",
+  "ragie",
+  "sendgrid",
+  "slack",
+  "discord",
+  "linear",
+  "clerk",
+  "custom"
+]);
+var TemplateMetadataSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
+  provider: WebhookProviderSchema,
+  event: z.string(),
+  file: z.string(),
+  version: z.string().optional(),
+  docsUrl: z.string().url().optional()
+});
+var TemplatesIndexSchema = z.object({
+  version: z.string(),
+  templates: z.array(TemplateMetadataSchema)
+});
+var WebhookTemplateSchema = z.object({
+  url: z.string().url().optional(),
+  method: HttpMethodSchema.default("POST"),
+  headers: z.array(HeaderEntrySchema).default([]),
+  body: z.any().optional(),
+  provider: WebhookProviderSchema.optional(),
+  event: z.string().optional(),
+  description: z.string().optional()
+});
+var CapturedWebhookSchema = z.object({
+  id: z.string(),
+  timestamp: z.string(),
+  method: HttpMethodSchema,
+  url: z.string(),
+  path: z.string(),
+  headers: z.record(z.union([z.string(), z.array(z.string())])),
+  body: z.any().optional(),
+  rawBody: z.string(),
+  query: z.record(z.union([z.string(), z.array(z.string())])),
+  provider: WebhookProviderSchema.optional(),
+  contentType: z.string().optional(),
+  contentLength: z.number().optional()
+});
+var ConfigSchema = z.object({
+  version: z.string().default("2.0.0"),
+  templatesDir: z.string().optional(),
+  capturesDir: z.string().optional(),
+  defaultTargetUrl: z.string().url().optional(),
+  secrets: z.record(z.string()).optional().describe("Provider secrets for signature generation"),
+  dashboard: z.object({
+    port: z.number().default(4e3),
+    host: z.string().default("localhost")
+  }).optional(),
+  capture: z.object({
+    port: z.number().default(3001),
+    host: z.string().default("0.0.0.0")
+  }).optional()
 });
-var webhookSchema = z.object({
-  url: z.string().url("Invalid URL"),
-  method: httpMethodSchema.default("POST"),
-  headers: z.array(headerEntrySchema).default([]),
-  body: z.any().optional()
-  // could be anything JSON-serializable
-}).strict();
-function validateWebhookJSON(raw, source) {
-  const parsed = webhookSchema.safeParse(raw);
-  if (!parsed.success) {
-    const issues = parsed.error.issues.map((i) => `- ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n");
-    throw new Error(`Invalid webhook definition in ${source}:
-${issues}`);
-  }
-  return parsed.data;
-}
 
-// src/utils/http.ts
-import { request } from "undici";
-async function executeWebhook(def) {
-  const headerMap = {};
-  for (const h of def.headers) {
-    headerMap[h.key] = h.value;
-  }
-  if (!headerMap["content-type"] && def.body !== void 0) {
-    headerMap["content-type"] = "application/json";
-  }
-  const bodyPayload = def.body !== void 0 ? JSON.stringify(def.body) : void 0;
-  const { statusCode, headers, body } = await request(def.url, {
-    method: def.method,
-    headers: headerMap,
-    body: bodyPayload
-  });
-  const text = await body.text();
-  let parsed;
-  if (text) {
+// 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 TemplateManager = class {
+  baseDir;
+  templatesDir;
+  cacheFile;
+  indexCache = null;
+  constructor(baseDir) {
+    this.baseDir = baseDir || join(homedir(), ".better-webhook");
+    this.templatesDir = join(this.baseDir, "templates");
+    this.cacheFile = join(this.baseDir, "templates-cache.json");
+    if (!existsSync(this.baseDir)) {
+      mkdirSync(this.baseDir, { recursive: true });
+    }
+    if (!existsSync(this.templatesDir)) {
+      mkdirSync(this.templatesDir, { recursive: true });
+    }
+  }
+  /**
+   * Get the templates directory path
+   */
+  getTemplatesDir() {
+    return this.templatesDir;
+  }
+  /**
+   * Fetch templates index from GitHub
+   */
+  async fetchRemoteIndex(forceRefresh = false) {
+    if (!forceRefresh && this.indexCache) {
+      return this.indexCache;
+    }
+    if (!forceRefresh && existsSync(this.cacheFile)) {
+      try {
+        const cached = JSON.parse(readFileSync(this.cacheFile, "utf-8"));
+        const cacheAge = Date.now() - (cached.cachedAt || 0);
+        if (cacheAge < 36e5) {
+          this.indexCache = cached.index;
+          return cached.index;
+        }
+      } catch {
+      }
+    }
+    try {
+      const { statusCode, body } = await request(TEMPLATES_INDEX_URL);
+      if (statusCode !== 200) {
+        throw new Error(`HTTP ${statusCode}`);
+      }
+      const text = await body.text();
+      const json = JSON.parse(text);
+      const index = TemplatesIndexSchema.parse(json);
+      this.indexCache = index;
+      writeFileSync(
+        this.cacheFile,
+        JSON.stringify({ index, cachedAt: Date.now() }, null, 2)
+      );
+      return index;
+    } catch (error) {
+      if (existsSync(this.cacheFile)) {
+        try {
+          const cached = JSON.parse(readFileSync(this.cacheFile, "utf-8"));
+          if (cached.index) {
+            this.indexCache = cached.index;
+            return cached.index;
+          }
+        } catch {
+        }
+      }
+      throw new Error(`Failed to fetch templates index: ${error.message}`);
+    }
+  }
+  /**
+   * List all remote templates
+   */
+  async listRemoteTemplates(options) {
+    const index = await this.fetchRemoteIndex(!!options?.forceRefresh);
+    const localIds = new Set(this.listLocalTemplates().map((t) => t.id));
+    return index.templates.map((metadata) => ({
+      metadata,
+      isDownloaded: localIds.has(metadata.id)
+    }));
+  }
+  /**
+   * Download a template by ID
+   */
+  async downloadTemplate(templateId) {
+    const index = await this.fetchRemoteIndex();
+    const templateMeta = index.templates.find((t) => t.id === templateId);
+    if (!templateMeta) {
+      throw new Error(`Template not found: ${templateId}`);
+    }
+    const templateUrl = `${GITHUB_RAW_BASE}/templates/${templateMeta.file}`;
+    try {
+      const { statusCode, body } = await request(templateUrl);
+      if (statusCode !== 200) {
+        throw new Error(`HTTP ${statusCode}`);
+      }
+      const text = await body.text();
+      const json = JSON.parse(text);
+      const template = WebhookTemplateSchema.parse(json);
+      const providerDir = join(this.templatesDir, templateMeta.provider);
+      if (!existsSync(providerDir)) {
+        mkdirSync(providerDir, { recursive: true });
+      }
+      const fileName = `${templateId}.json`;
+      const filePath = join(providerDir, fileName);
+      const localTemplate = {
+        id: templateId,
+        metadata: templateMeta,
+        template,
+        downloadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        filePath
+      };
+      const saveData = {
+        ...template,
+        _metadata: {
+          ...templateMeta,
+          downloadedAt: localTemplate.downloadedAt
+        }
+      };
+      writeFileSync(filePath, JSON.stringify(saveData, null, 2));
+      return localTemplate;
+    } catch (error) {
+      throw new Error(
+        `Failed to download template ${templateId}: ${error.message}`
+      );
+    }
+  }
+  /**
+   * List all downloaded local templates
+   */
+  listLocalTemplates() {
+    const templates2 = [];
+    if (!existsSync(this.templatesDir)) {
+      return templates2;
+    }
+    const scanDir = (dir) => {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          scanDir(fullPath);
+        } else if (entry.isFile() && entry.name.endsWith(".json")) {
+          try {
+            const content = JSON.parse(readFileSync(fullPath, "utf-8"));
+            const metadata = content._metadata;
+            if (metadata) {
+              const { _metadata, ...templateData } = content;
+              templates2.push({
+                id: metadata.id,
+                metadata,
+                template: templateData,
+                downloadedAt: metadata.downloadedAt || (/* @__PURE__ */ new Date()).toISOString(),
+                filePath: fullPath
+              });
+            } else {
+              const id = basename(entry.name, ".json");
+              templates2.push({
+                id,
+                metadata: {
+                  id,
+                  name: id,
+                  provider: "custom",
+                  event: "unknown",
+                  file: entry.name
+                },
+                template: content,
+                downloadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                filePath: fullPath
+              });
+            }
+          } catch {
+          }
+        }
+      }
+    };
+    scanDir(this.templatesDir);
+    return templates2;
+  }
+  /**
+   * Get a specific local template by ID
+   */
+  getLocalTemplate(templateId) {
+    const templates2 = this.listLocalTemplates();
+    return templates2.find((t) => t.id === templateId) || null;
+  }
+  /**
+   * Delete a local template
+   */
+  deleteLocalTemplate(templateId) {
+    const template = this.getLocalTemplate(templateId);
+    if (!template) {
+      return false;
+    }
     try {
-      parsed = JSON.parse(text);
+      unlinkSync(template.filePath);
+      return true;
     } catch {
+      return false;
     }
   }
-  const resultHeaders = {};
-  for (const [k, v] of Object.entries(headers)) {
-    resultHeaders[k] = v;
+  /**
+   * Search templates by name, provider, or event
+   */
+  async searchTemplates(query) {
+    const queryLower = query.toLowerCase();
+    const remote = await this.listRemoteTemplates();
+    const local = this.listLocalTemplates();
+    const matchesMeta = (meta) => {
+      return meta.id.toLowerCase().includes(queryLower) || meta.name.toLowerCase().includes(queryLower) || meta.provider.toLowerCase().includes(queryLower) || meta.event.toLowerCase().includes(queryLower) || (meta.description?.toLowerCase().includes(queryLower) ?? false);
+    };
+    return {
+      remote: remote.filter((t) => matchesMeta(t.metadata)),
+      local: local.filter((t) => matchesMeta(t.metadata))
+    };
   }
-  return {
-    status: statusCode,
-    headers: resultHeaders,
-    bodyText: text,
-    json: parsed
-  };
-}
-
-// src/utils/index.ts
-function findWebhooksDir(cwd) {
-  return resolve(cwd, ".webhooks");
-}
-function listWebhookFiles(dir) {
-  return listJsonFiles(dir);
-}
-function findCapturesDir(cwd) {
-  return resolve(cwd, ".webhook-captures");
-}
-function listJsonFiles(dir) {
-  try {
-    const entries = readdirSync(dir);
-    return entries.filter(
-      (e) => statSync(join(dir, e)).isFile() && extname(e) === ".json"
-    );
-  } catch {
-    return [];
+  /**
+   * Clear the templates cache
+   */
+  clearCache() {
+    this.indexCache = null;
+    if (existsSync(this.cacheFile)) {
+      unlinkSync(this.cacheFile);
+    }
   }
-}
-function loadWebhookFile(path) {
-  let rawContent;
-  try {
-    rawContent = readFileSync(path, "utf8");
-  } catch (e) {
-    throw new Error(`Failed to read file ${path}: ${e.message}`);
+  /**
+   * Delete all local templates
+   * @returns Number of templates deleted
+   */
+  deleteAllLocalTemplates() {
+    const templates2 = this.listLocalTemplates();
+    let deleted = 0;
+    for (const template of templates2) {
+      try {
+        unlinkSync(template.filePath);
+        deleted++;
+      } catch {
+      }
+    }
+    if (existsSync(this.templatesDir)) {
+      const entries = readdirSync(this.templatesDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const dirPath = join(this.templatesDir, entry.name);
+          try {
+            const contents = readdirSync(dirPath);
+            if (contents.length === 0) {
+              rmdirSync(dirPath);
+            }
+          } catch {
+          }
+        }
+      }
+    }
+    return deleted;
   }
-  let json;
-  try {
-    json = JSON.parse(rawContent);
-  } catch (e) {
-    throw new Error(`Invalid JSON in file ${path}: ${e.message}`);
+};
+var instance = null;
+function getTemplateManager(baseDir) {
+  if (!instance) {
+    instance = new TemplateManager(baseDir);
   }
-  return validateWebhookJSON(json, path);
+  return instance;
 }
 
-// src/commands/webhooks.ts
-import { mkdirSync, writeFileSync, existsSync } from "fs";
-import { request as request2 } from "undici";
-
-// src/config.ts
-var TEMPLATE_REPO_BASE = "https://raw.githubusercontent.com/endalk200/better-webhook/main";
-var TEMPLATES = {
-  "stripe-invoice.payment_succeeded": "templates/stripe-invoice.payment_succeeded.json"
-};
-
-// src/commands/webhooks.ts
-import prompts from "prompts";
-import ora from "ora";
-function statExists(p) {
+// src/commands/templates.ts
+var listCommand = new Command().name("list").alias("ls").description("List available remote templates from the repository").option(
+  "-p, --provider <provider>",
+  "Filter by provider (stripe, github, etc.)"
+).option("-r, --refresh", "Force refresh the template index cache").action(async (options) => {
+  const spinner = ora("Fetching remote templates...").start();
   try {
-    statSync2(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-var listCommand = new Command().name("list").description("List available webhook JSON definitions in .webhooks directory").action(() => {
-  const cwd = process.cwd();
-  const dir = findWebhooksDir(cwd);
-  const files = listWebhookFiles(dir);
-  if (!files.length) {
-    console.log("\u{1F4ED} No webhook definitions found in .webhooks directory.");
-    console.log("\u{1F4A1} Create webhook files or download templates with:");
-    console.log("   better-webhook webhooks download --all");
-    return;
-  }
-  console.log("Available webhook definitions:");
-  files.forEach((f) => console.log(`  \u2022 ${basename(f, ".json")}`));
-});
-var runCommand = new Command().name("run").argument(
-  "[nameOrPath]",
-  "Webhook name (in .webhooks) or path to JSON file (optional - will prompt if not provided)"
-).description(
-  "Run a webhook by name (in .webhooks) or by providing a path to a JSON file"
-).option("-u, --url <url>", "Override destination URL").option("-m, --method <method>", "Override HTTP method").action(async (nameOrPath, options = {}) => {
-  const cwd = process.cwd();
-  const webhooksDir = findWebhooksDir(cwd);
-  let selectedNameOrPath = nameOrPath;
-  if (!selectedNameOrPath) {
-    const spinner = ora("Loading available webhooks...").start();
-    const localFiles = listWebhookFiles(webhooksDir);
-    const templates = Object.keys(TEMPLATES);
+    const manager = getTemplateManager();
+    const templates2 = await manager.listRemoteTemplates({
+      forceRefresh: !!options.refresh
+    });
     spinner.stop();
-    if (localFiles.length === 0 && templates.length === 0) {
-      console.log("\u{1F4ED} No webhook definitions found.");
-      console.log(
-        "\u{1F4A1} Create webhook files in .webhooks directory or download templates with:"
-      );
-      console.log("   better-webhook webhooks download --all");
+    if (templates2.length === 0) {
+      console.log(chalk.yellow("\u{1F4ED} No remote templates found."));
       return;
     }
-    const choices = [];
-    if (localFiles.length > 0) {
-      choices.push(
-        {
-          title: "--- Local Webhooks (.webhooks) ---",
-          description: "",
-          value: "",
-          type: "separator"
-        },
-        ...localFiles.map((file) => ({
-          title: basename(file, ".json"),
-          description: `Local file: ${file}`,
-          value: basename(file, ".json"),
-          type: "local"
-        }))
+    let filtered = templates2;
+    if (options.provider) {
+      filtered = templates2.filter(
+        (t) => t.metadata.provider.toLowerCase() === options.provider?.toLowerCase()
       );
     }
-    if (templates.length > 0) {
-      choices.push(
-        {
-          title: "--- Available Templates ---",
-          description: "",
-          value: "",
-          type: "separator"
-        },
-        ...templates.map((template) => ({
-          title: template,
-          description: `Template: ${TEMPLATES[template]}`,
-          value: template,
-          type: "template"
-        }))
+    if (filtered.length === 0) {
+      console.log(
+        chalk.yellow(
+          `\u{1F4ED} No templates found for provider: ${options.provider}`
+        )
       );
+      return;
     }
-    const response = await prompts({
-      type: "select",
-      name: "webhook",
-      message: "Select a webhook to run:",
-      choices: choices.filter((choice) => choice.value !== ""),
-      // Remove separators for selection
-      initial: 0
-    });
-    if (!response.webhook) {
-      console.log("\u274C No webhook selected. Exiting.");
-      process.exitCode = 1;
+    console.log(chalk.bold("\n\u{1F4E6} Available Templates\n"));
+    const byProvider = /* @__PURE__ */ new Map();
+    for (const t of filtered) {
+      const provider = t.metadata.provider;
+      if (!byProvider.has(provider)) {
+        byProvider.set(provider, []);
+      }
+      byProvider.get(provider).push(t);
+    }
+    for (const [provider, providerTemplates] of byProvider) {
+      console.log(chalk.cyan.bold(`  ${provider.toUpperCase()}`));
+      for (const t of providerTemplates) {
+        const status = t.isDownloaded ? chalk.green("\u2713 downloaded") : chalk.gray("\u25CB remote");
+        console.log(`    ${chalk.white(t.metadata.id)} ${status}`);
+        if (t.metadata.description) {
+          console.log(chalk.gray(`      ${t.metadata.description}`));
+        }
+      }
+      console.log();
+    }
+    console.log(chalk.gray(`  Total: ${filtered.length} templates`));
+    console.log(
+      chalk.gray(`  Download: better-webhook templates download <id>
+`)
+    );
+  } catch (error) {
+    spinner.fail("Failed to fetch templates");
+    console.error(chalk.red(error.message));
+    process.exitCode = 1;
+  }
+});
+var downloadCommand = new Command().name("download").alias("get").argument("[templateId]", "Template ID to download").description("Download a template to local storage").option("-a, --all", "Download all available templates").option("-r, --refresh", "Force refresh the template index cache").action(
+  async (templateId, options) => {
+    const manager = getTemplateManager();
+    if (options?.all) {
+      const spinner2 = ora("Fetching template list...").start();
+      try {
+        const templates2 = await manager.listRemoteTemplates({
+          forceRefresh: true
+        });
+        const toDownload = templates2.filter((t) => !t.isDownloaded);
+        spinner2.stop();
+        if (toDownload.length === 0) {
+          console.log(chalk.green("\u2713 All templates already downloaded"));
+          return;
+        }
+        console.log(
+          chalk.bold(`
+Downloading ${toDownload.length} templates...
+`)
+        );
+        for (const t of toDownload) {
+          const downloadSpinner = ora(
+            `Downloading ${t.metadata.id}...`
+          ).start();
+          try {
+            await manager.downloadTemplate(t.metadata.id);
+            downloadSpinner.succeed(`Downloaded ${t.metadata.id}`);
+          } catch (error) {
+            downloadSpinner.fail(
+              `Failed: ${t.metadata.id} - ${error.message}`
+            );
+          }
+        }
+        console.log(chalk.green("\n\u2713 Download complete\n"));
+      } catch (error) {
+        spinner2.fail("Failed to fetch templates");
+        console.error(chalk.red(error.message));
+        process.exitCode = 1;
+      }
       return;
     }
-    selectedNameOrPath = response.webhook;
-    if (selectedNameOrPath && templates.includes(selectedNameOrPath)) {
-      const downloadSpinner = ora(
-        `Downloading template: ${selectedNameOrPath}...`
-      ).start();
+    if (!templateId) {
+      const spinner2 = ora("Fetching templates...").start();
       try {
-        const rel = TEMPLATES[selectedNameOrPath];
-        const rawUrl = `${TEMPLATE_REPO_BASE}/${rel}`;
-        const { statusCode, body } = await request2(rawUrl);
-        if (statusCode !== 200) {
-          throw new Error(`HTTP ${statusCode}`);
+        const templates2 = await manager.listRemoteTemplates({
+          forceRefresh: !!options?.refresh
+        });
+        spinner2.stop();
+        const notDownloaded = templates2.filter((t) => !t.isDownloaded);
+        if (notDownloaded.length === 0) {
+          console.log(chalk.green("\u2713 All templates already downloaded"));
+          return;
+        }
+        const choices = notDownloaded.map((t) => ({
+          title: t.metadata.id,
+          description: `${t.metadata.provider} - ${t.metadata.event}`,
+          value: t.metadata.id
+        }));
+        const response = await prompts({
+          type: "select",
+          name: "templateId",
+          message: "Select a template to download:",
+          choices
+        });
+        if (!response.templateId) {
+          console.log(chalk.yellow("Cancelled"));
+          return;
         }
-        const text = await body.text();
-        const json = JSON.parse(text);
-        validateWebhookJSON(json, rawUrl);
-        mkdirSync(webhooksDir, { recursive: true });
-        const fileName = basename(rel);
-        const destPath = join2(webhooksDir, fileName);
-        writeFileSync(destPath, JSON.stringify(json, null, 2));
-        selectedNameOrPath = basename(fileName, ".json");
-        downloadSpinner.succeed(`Downloaded template: ${selectedNameOrPath}`);
+        templateId = response.templateId;
       } catch (error) {
-        downloadSpinner.fail(`Failed to download template: ${error.message}`);
+        spinner2.fail("Failed to fetch templates");
+        console.error(chalk.red(error.message));
         process.exitCode = 1;
         return;
       }
     }
+    const spinner = ora(`Downloading ${templateId}...`).start();
+    try {
+      const template = await manager.downloadTemplate(templateId);
+      spinner.succeed(`Downloaded ${templateId}`);
+      console.log(chalk.gray(`  Saved to: ${template.filePath}`));
+      console.log(
+        chalk.gray(`  Run with: better-webhook run ${templateId}
+`)
+      );
+    } catch (error) {
+      spinner.fail(`Failed to download ${templateId}`);
+      console.error(chalk.red(error.message));
+      process.exitCode = 1;
+    }
   }
-  if (!selectedNameOrPath) {
-    console.error("\u274C No webhook selected.");
-    process.exitCode = 1;
-    return;
+);
+var localCommand = new Command().name("local").description("List downloaded local templates").option("-p, --provider <provider>", "Filter by provider").action((options) => {
+  const manager = getTemplateManager();
+  let templates2 = manager.listLocalTemplates();
+  if (options.provider) {
+    templates2 = templates2.filter(
+      (t) => t.metadata.provider.toLowerCase() === options.provider?.toLowerCase()
+    );
   }
-  let filePath;
-  if (selectedNameOrPath.endsWith(".json") && !selectedNameOrPath.includes("/") && !selectedNameOrPath.startsWith(".")) {
-    filePath = join2(webhooksDir, selectedNameOrPath);
-  } else {
-    const candidate = join2(
-      webhooksDir,
-      selectedNameOrPath + (selectedNameOrPath.endsWith(".json") ? "" : ".json")
+  if (templates2.length === 0) {
+    console.log(chalk.yellow("\n\u{1F4ED} No local templates found."));
+    console.log(
+      chalk.gray(
+        "   Download templates with: better-webhook templates download\n"
+      )
     );
-    if (statExists(candidate)) {
-      filePath = candidate;
-    } else {
-      filePath = resolve2(cwd, selectedNameOrPath);
+    return;
+  }
+  console.log(chalk.bold("\n\u{1F4C1} Local Templates\n"));
+  const byProvider = /* @__PURE__ */ new Map();
+  for (const t of templates2) {
+    const provider = t.metadata.provider;
+    if (!byProvider.has(provider)) {
+      byProvider.set(provider, []);
     }
+    byProvider.get(provider).push(t);
   }
-  if (!statExists(filePath)) {
-    console.error(`Webhook file not found: ${filePath}`);
-    process.exitCode = 1;
-    return;
+  for (const [provider, providerTemplates] of byProvider) {
+    console.log(chalk.cyan.bold(`  ${provider.toUpperCase()}`));
+    for (const t of providerTemplates) {
+      console.log(`    ${chalk.white(t.id)}`);
+      console.log(chalk.gray(`      Event: ${t.metadata.event}`));
+      console.log(
+        chalk.gray(
+          `      Downloaded: ${new Date(t.downloadedAt).toLocaleDateString()}`
+        )
+      );
+    }
+    console.log();
   }
-  let def;
+  console.log(chalk.gray(`  Total: ${templates2.length} templates`));
+  console.log(chalk.gray(`  Storage: ${manager.getTemplatesDir()}
+`));
+});
+var searchCommand = new Command().name("search").argument("<query>", "Search query").description("Search templates by name, provider, or event").action(async (query) => {
+  const spinner = ora("Searching...").start();
   try {
-    def = loadWebhookFile(filePath);
-  } catch (err) {
-    console.error(err.message);
+    const manager = getTemplateManager();
+    const results = await manager.searchTemplates(query);
+    spinner.stop();
+    const totalCount = results.remote.length + results.local.length;
+    if (totalCount === 0) {
+      console.log(chalk.yellow(`
+\u{1F4ED} No templates found for: "${query}"
+`));
+      return;
+    }
+    console.log(chalk.bold(`
+\u{1F50D} Search Results for "${query}"
+`));
+    if (results.local.length > 0) {
+      console.log(chalk.cyan.bold("  LOCAL TEMPLATES"));
+      for (const t of results.local) {
+        console.log(
+          `    ${chalk.green("\u2713")} ${t.id} (${t.metadata.provider})`
+        );
+      }
+      console.log();
+    }
+    if (results.remote.length > 0) {
+      console.log(chalk.cyan.bold("  REMOTE TEMPLATES"));
+      for (const t of results.remote) {
+        const status = t.isDownloaded ? chalk.green("\u2713") : chalk.gray("\u25CB");
+        console.log(
+          `    ${status} ${t.metadata.id} (${t.metadata.provider})`
+        );
+      }
+      console.log();
+    }
+    console.log(chalk.gray(`  Found: ${totalCount} templates
+`));
+  } catch (error) {
+    spinner.fail("Search failed");
+    console.error(chalk.red(error.message));
     process.exitCode = 1;
+  }
+});
+var cacheCommand = new Command().name("cache").description("Manage template cache").option("-c, --clear", "Clear the template cache").action((options) => {
+  if (options.clear) {
+    const manager = getTemplateManager();
+    manager.clearCache();
+    console.log(chalk.green("\u2713 Template cache cleared"));
+  } else {
+    console.log("Use --clear to clear the template cache");
+  }
+});
+var cleanCommand = new Command().name("clean").alias("remove-all").description("Remove all downloaded templates").option("-f, --force", "Skip confirmation prompt").action(async (options) => {
+  const manager = getTemplateManager();
+  const templates2 = manager.listLocalTemplates();
+  if (templates2.length === 0) {
+    console.log(chalk.yellow("\n\u{1F4ED} No local templates to remove.\n"));
     return;
   }
-  if (options.url) def = { ...def, url: options.url };
-  if (options.method)
-    def = { ...def, method: options.method.toUpperCase() };
-  const executeSpinner = ora(
-    `Executing webhook: ${basename(filePath, ".json")}...`
-  ).start();
-  try {
-    const result = await executeWebhook(def);
-    executeSpinner.succeed("Webhook executed successfully!");
-    console.log("Status:", result.status);
-    console.log("Headers:");
-    for (const [k, v] of Object.entries(result.headers)) {
-      console.log(`  ${k}: ${Array.isArray(v) ? v.join(", ") : v}`);
-    }
-    if (result.json !== void 0) {
-      console.log("Response JSON:");
-      console.log(JSON.stringify(result.json, null, 2));
-    } else {
-      console.log("Response Body:");
-      console.log(result.bodyText);
+  console.log(
+    chalk.bold(`
+\u{1F5D1}\uFE0F  Found ${templates2.length} downloaded template(s)
+`)
+  );
+  for (const t of templates2) {
+    console.log(chalk.gray(`    ${t.id} (${t.metadata.provider})`));
+  }
+  console.log();
+  if (!options.force) {
+    const response = await prompts({
+      type: "confirm",
+      name: "confirm",
+      message: `Delete all ${templates2.length} template(s)?`,
+      initial: false
+    });
+    if (!response.confirm) {
+      console.log(chalk.yellow("Cancelled"));
+      return;
     }
-  } catch (err) {
-    executeSpinner.fail("Request failed");
-    console.error("Error:", err.message);
-    process.exitCode = 1;
   }
+  const deleted = manager.deleteAllLocalTemplates();
+  console.log(chalk.green(`
+\u2713 Removed ${deleted} template(s)`));
+  console.log(chalk.gray(`  Storage: ${manager.getTemplatesDir()}
+`));
 });
-var downloadCommand = new Command().name("download").argument("[name]", "Template name to download").description(
-  "Download official webhook template(s) into the .webhooks directory. If no name is provided, prints available templates."
-).option("-a, --all", "Download all available templates").option("-f, --force", "Overwrite existing files if they exist").action(
-  async (name, opts) => {
-    if (name && opts.all) {
-      console.error("Specify either a template name or --all, not both.");
-      process.exitCode = 1;
-      return;
+var templates = new Command().name("templates").alias("t").description("Manage webhook templates").addCommand(listCommand).addCommand(downloadCommand).addCommand(localCommand).addCommand(searchCommand).addCommand(cacheCommand).addCommand(cleanCommand);
+
+// src/commands/run.ts
+import { Command as Command2 } from "commander";
+import ora2 from "ora";
+import prompts2 from "prompts";
+import chalk2 from "chalk";
+
+// src/core/executor.ts
+import { request as request2 } from "undici";
+
+// src/core/signature.ts
+import { createHmac } from "crypto";
+function generateStripeSignature(payload, secret, timestamp) {
+  const ts = timestamp || Math.floor(Date.now() / 1e3);
+  const signedPayload = `${ts}.${payload}`;
+  const signature = createHmac("sha256", secret).update(signedPayload).digest("hex");
+  return {
+    header: "Stripe-Signature",
+    value: `t=${ts},v1=${signature}`
+  };
+}
+function generateGitHubSignature(payload, secret) {
+  const signature = createHmac("sha256", secret).update(payload).digest("hex");
+  return {
+    header: "X-Hub-Signature-256",
+    value: `sha256=${signature}`
+  };
+}
+function generateShopifySignature(payload, secret) {
+  const signature = createHmac("sha256", secret).update(payload).digest("base64");
+  return {
+    header: "X-Shopify-Hmac-SHA256",
+    value: signature
+  };
+}
+function generateTwilioSignature(payload, secret, url) {
+  const signatureInput = url + payload;
+  const signature = createHmac("sha1", secret).update(signatureInput).digest("base64");
+  return {
+    header: "X-Twilio-Signature",
+    value: signature
+  };
+}
+function generateSlackSignature(payload, secret, timestamp) {
+  const ts = timestamp || Math.floor(Date.now() / 1e3);
+  const signatureBaseString = `v0:${ts}:${payload}`;
+  const signature = createHmac("sha256", secret).update(signatureBaseString).digest("hex");
+  return {
+    header: "X-Slack-Signature",
+    value: `v0=${signature}`
+  };
+}
+function generateLinearSignature(payload, secret) {
+  const signature = createHmac("sha256", secret).update(payload).digest("hex");
+  return {
+    header: "Linear-Signature",
+    value: signature
+  };
+}
+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 = createHmac("sha256", secret).update(signedPayload).digest("base64");
+  return {
+    header: "Svix-Signature",
+    value: `v1,${signature}`
+  };
+}
+function generateSendGridSignature(payload, secret, timestamp) {
+  const ts = timestamp || Math.floor(Date.now() / 1e3);
+  const signedPayload = `${ts}${payload}`;
+  const signature = createHmac("sha256", secret).update(signedPayload).digest("base64");
+  return {
+    header: "X-Twilio-Email-Event-Webhook-Signature",
+    value: signature
+  };
+}
+function generateSignature(provider, payload, secret, options) {
+  const timestamp = options?.timestamp;
+  switch (provider) {
+    case "stripe":
+      return generateStripeSignature(payload, secret, timestamp);
+    case "github":
+      return generateGitHubSignature(payload, secret);
+    case "shopify":
+      return generateShopifySignature(payload, secret);
+    case "twilio":
+      if (!options?.url) {
+        throw new Error("Twilio signature requires URL");
+      }
+      return generateTwilioSignature(payload, secret, options.url);
+    case "slack":
+      return generateSlackSignature(payload, secret, timestamp);
+    case "linear":
+      return generateLinearSignature(payload, secret);
+    case "clerk":
+      return generateClerkSignature(
+        payload,
+        secret,
+        timestamp,
+        options?.webhookId
+      );
+    case "sendgrid":
+      return generateSendGridSignature(payload, secret, timestamp);
+    case "discord":
+    case "custom":
+    default:
+      return null;
+  }
+}
+function getProviderHeaders(provider, options) {
+  const headers = [];
+  const timestamp = options?.timestamp || Math.floor(Date.now() / 1e3);
+  switch (provider) {
+    case "stripe":
+      headers.push(
+        { key: "Content-Type", value: "application/json" },
+        {
+          key: "User-Agent",
+          value: "Stripe/1.0 (+https://stripe.com/docs/webhooks)"
+        }
+      );
+      break;
+    case "github":
+      headers.push(
+        { key: "Content-Type", value: "application/json" },
+        { key: "User-Agent", value: "GitHub-Hookshot/better-webhook" },
+        { key: "X-GitHub-Event", value: options?.event || "push" },
+        {
+          key: "X-GitHub-Delivery",
+          value: options?.webhookId || generateDeliveryId()
+        }
+      );
+      break;
+    case "shopify":
+      headers.push(
+        { key: "Content-Type", value: "application/json" },
+        { key: "X-Shopify-Topic", value: options?.event || "orders/create" },
+        { key: "X-Shopify-Shop-Domain", value: "example.myshopify.com" },
+        { key: "X-Shopify-API-Version", value: "2024-01" }
+      );
+      break;
+    case "slack":
+      headers.push(
+        { key: "Content-Type", value: "application/json" },
+        { key: "X-Slack-Request-Timestamp", value: String(timestamp) }
+      );
+      break;
+    case "clerk":
+      headers.push(
+        { key: "Content-Type", value: "application/json" },
+        { key: "Svix-Id", value: options?.webhookId || `msg_${Date.now()}` },
+        { key: "Svix-Timestamp", value: String(timestamp) }
+      );
+      break;
+    case "sendgrid":
+      headers.push(
+        { key: "Content-Type", value: "application/json" },
+        {
+          key: "X-Twilio-Email-Event-Webhook-Timestamp",
+          value: String(timestamp)
+        }
+      );
+      break;
+    case "twilio":
+      headers.push({
+        key: "Content-Type",
+        value: "application/x-www-form-urlencoded"
+      });
+      break;
+    case "linear":
+      headers.push(
+        { key: "Content-Type", value: "application/json" },
+        {
+          key: "Linear-Delivery",
+          value: options?.webhookId || generateDeliveryId()
+        }
+      );
+      break;
+    case "discord":
+      headers.push(
+        { key: "Content-Type", value: "application/json" },
+        { key: "User-Agent", value: "Discord-Webhook/1.0" }
+      );
+      break;
+    default:
+      headers.push({ key: "Content-Type", value: "application/json" });
+  }
+  return headers;
+}
+function generateDeliveryId() {
+  const chars = "0123456789abcdef";
+  let id = "";
+  for (let i = 0; i < 36; i++) {
+    if (i === 8 || i === 13 || i === 18 || i === 23) {
+      id += "-";
+    } else {
+      id += chars[Math.floor(Math.random() * chars.length)];
     }
-    const cwd = process.cwd();
-    const dir = findWebhooksDir(cwd);
-    mkdirSync(dir, { recursive: true });
-    const toDownload = opts.all ? Object.keys(TEMPLATES) : name ? [name] : [];
-    if (!toDownload.length) {
-      console.log("Available templates:");
-      for (const key of Object.keys(TEMPLATES)) console.log(` - ${key}`);
-      console.log("Use: better-webhook webhooks download <name> OR --all");
-      return;
+  }
+  return id;
+}
+
+// src/core/executor.ts
+async function executeWebhook(options) {
+  const startTime = Date.now();
+  let bodyStr;
+  if (options.body !== void 0) {
+    bodyStr = typeof options.body === "string" ? options.body : JSON.stringify(options.body);
+  }
+  const headers = {};
+  if (options.provider) {
+    const providerHeaders = getProviderHeaders(options.provider);
+    for (const h of providerHeaders) {
+      headers[h.key] = h.value;
     }
-    for (const templateName of toDownload) {
-      const rel = TEMPLATES[templateName];
-      if (!rel) {
-        console.error(
-          `Unknown template '${templateName}'. Run without arguments to list available templates.`
-        );
-        continue;
+  }
+  if (options.headers) {
+    for (const h of options.headers) {
+      headers[h.key] = h.value;
+    }
+  }
+  if (options.secret && options.provider && bodyStr) {
+    const sig = generateSignature(options.provider, bodyStr, options.secret, {
+      url: options.url
+    });
+    if (sig) {
+      headers[sig.header] = sig.value;
+    }
+  }
+  if (!headers["Content-Type"] && !headers["content-type"]) {
+    headers["Content-Type"] = "application/json";
+  }
+  try {
+    const response = await request2(options.url, {
+      method: options.method || "POST",
+      headers,
+      body: bodyStr,
+      headersTimeout: options.timeout || 3e4,
+      bodyTimeout: options.timeout || 3e4
+    });
+    const bodyText = await response.body.text();
+    const duration = Date.now() - startTime;
+    const responseHeaders = {};
+    for (const [key, value] of Object.entries(response.headers)) {
+      if (value !== void 0) {
+        responseHeaders[key] = value;
+      }
+    }
+    let json;
+    try {
+      json = JSON.parse(bodyText);
+    } catch {
+    }
+    return {
+      status: response.statusCode,
+      statusText: getStatusText(response.statusCode),
+      headers: responseHeaders,
+      body: json ?? bodyText,
+      bodyText,
+      json,
+      duration
+    };
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    throw new ExecutionError(error.message, duration);
+  }
+}
+async function executeTemplate(template, options = {}) {
+  const targetUrl = options.url || template.url;
+  if (!targetUrl) {
+    throw new Error(
+      "No target URL specified. Use --url or set url in template."
+    );
+  }
+  const mergedHeaders = [...template.headers || []];
+  if (options.headers) {
+    for (const h of options.headers) {
+      const existingIdx = mergedHeaders.findIndex(
+        (mh) => mh.key.toLowerCase() === h.key.toLowerCase()
+      );
+      if (existingIdx >= 0) {
+        mergedHeaders[existingIdx] = h;
+      } else {
+        mergedHeaders.push(h);
       }
-      const rawUrl = `${TEMPLATE_REPO_BASE}/${rel}`;
+    }
+  }
+  return executeWebhook({
+    url: targetUrl,
+    method: template.method,
+    headers: mergedHeaders,
+    body: template.body,
+    secret: options.secret,
+    provider: template.provider
+  });
+}
+var ExecutionError = class extends Error {
+  duration;
+  constructor(message, duration) {
+    super(message);
+    this.name = "ExecutionError";
+    this.duration = duration;
+  }
+};
+function getStatusText(code) {
+  const statusTexts = {
+    200: "OK",
+    201: "Created",
+    202: "Accepted",
+    204: "No Content",
+    301: "Moved Permanently",
+    302: "Found",
+    304: "Not Modified",
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    405: "Method Not Allowed",
+    408: "Request Timeout",
+    409: "Conflict",
+    422: "Unprocessable Entity",
+    429: "Too Many Requests",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    504: "Gateway Timeout"
+  };
+  return statusTexts[code] || "Unknown";
+}
+
+// src/commands/run.ts
+function getSecretEnvVarName(provider) {
+  const envVarMap = {
+    github: "GITHUB_WEBHOOK_SECRET",
+    stripe: "STRIPE_WEBHOOK_SECRET",
+    shopify: "SHOPIFY_WEBHOOK_SECRET",
+    twilio: "TWILIO_WEBHOOK_SECRET",
+    ragie: "RAGIE_WEBHOOK_SECRET",
+    slack: "SLACK_WEBHOOK_SECRET",
+    linear: "LINEAR_WEBHOOK_SECRET",
+    clerk: "CLERK_WEBHOOK_SECRET",
+    sendgrid: "SENDGRID_WEBHOOK_SECRET",
+    discord: "DISCORD_WEBHOOK_SECRET",
+    custom: "WEBHOOK_SECRET"
+  };
+  return envVarMap[provider] || "WEBHOOK_SECRET";
+}
+var run = new Command2().name("run").argument("[templateId]", "Template ID to run").description("Run a webhook template against a target URL").requiredOption("-u, --url <url>", "Target URL to send the webhook to").option("-s, --secret <secret>", "Secret for signature generation").option(
+  "-H, --header <header>",
+  "Add custom header (format: key:value)",
+  (value, previous) => {
+    const [key, ...valueParts] = value.split(":");
+    const headerValue = valueParts.join(":");
+    if (!key || !headerValue) {
+      throw new Error("Header format should be key:value");
+    }
+    return (previous || []).concat([
+      { key: key.trim(), value: headerValue.trim() }
+    ]);
+  },
+  []
+).option("-v, --verbose", "Show detailed request/response information").action(
+  async (templateId, options) => {
+    const manager = getTemplateManager();
+    if (!templateId) {
+      const spinner2 = ora2("Loading templates...").start();
       try {
-        const { statusCode, body } = await request2(rawUrl);
-        if (statusCode !== 200) {
-          console.error(
-            `Failed to fetch ${templateName} (HTTP ${statusCode}) from ${rawUrl}`
+        const local = manager.listLocalTemplates();
+        const remote = await manager.listRemoteTemplates();
+        spinner2.stop();
+        if (local.length === 0 && remote.length === 0) {
+          console.log(chalk2.yellow("\n\u{1F4ED} No templates available."));
+          console.log(
+            chalk2.gray(
+              "   Download templates with: better-webhook templates download\n"
+            )
           );
-          continue;
+          return;
         }
-        const text = await body.text();
-        let json;
-        try {
-          json = JSON.parse(text);
-        } catch (e) {
-          console.error(
-            `Invalid JSON in remote template ${templateName}: ${e.message}`
-          );
-          continue;
+        const choices = [];
+        if (local.length > 0) {
+          for (const t of local) {
+            choices.push({
+              title: `${t.id} ${chalk2.green("(local)")}`,
+              description: `${t.metadata.provider} - ${t.metadata.event}`,
+              value: t.id
+            });
+          }
         }
-        try {
-          validateWebhookJSON(json, rawUrl);
-        } catch (e) {
-          console.error(`Template failed schema validation: ${e.message}`);
-          continue;
+        const remoteOnly = remote.filter((t) => !t.isDownloaded);
+        for (const t of remoteOnly) {
+          choices.push({
+            title: `${t.metadata.id} ${chalk2.gray("(remote)")}`,
+            description: `${t.metadata.provider} - ${t.metadata.event}`,
+            value: `remote:${t.metadata.id}`
+          });
         }
-        const fileName = basename(rel);
-        const destPath = join2(dir, fileName);
-        if (existsSync(destPath) && !opts.force) {
-          console.log(
-            `Skipping existing file ${fileName} (use --force to overwrite)`
-          );
-          continue;
+        const response = await prompts2({
+          type: "select",
+          name: "templateId",
+          message: "Select a template to run:",
+          choices
+        });
+        if (!response.templateId) {
+          console.log(chalk2.yellow("Cancelled"));
+          return;
+        }
+        templateId = response.templateId;
+      } catch (error) {
+        spinner2.fail("Failed to load templates");
+        console.error(chalk2.red(error.message));
+        process.exitCode = 1;
+        return;
+      }
+    }
+    if (templateId?.startsWith("remote:")) {
+      const remoteId = templateId.replace("remote:", "");
+      const downloadSpinner = ora2(`Downloading ${remoteId}...`).start();
+      try {
+        await manager.downloadTemplate(remoteId);
+        downloadSpinner.succeed(`Downloaded ${remoteId}`);
+        templateId = remoteId;
+      } catch (error) {
+        downloadSpinner.fail(`Failed to download: ${error.message}`);
+        process.exitCode = 1;
+        return;
+      }
+    }
+    const localTemplate = manager.getLocalTemplate(templateId);
+    if (!localTemplate) {
+      console.log(chalk2.red(`
+\u274C Template not found: ${templateId}`));
+      console.log(
+        chalk2.gray(
+          "   Download it with: better-webhook templates download " + templateId + "\n"
+        )
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const targetUrl = options.url;
+    let secret = options?.secret;
+    if (!secret && localTemplate.metadata.provider) {
+      const envVarName = getSecretEnvVarName(localTemplate.metadata.provider);
+      secret = process.env[envVarName];
+    }
+    console.log(chalk2.bold("\n\u{1F680} Executing Webhook\n"));
+    console.log(chalk2.gray(`   Template: ${templateId}`));
+    console.log(
+      chalk2.gray(`   Provider: ${localTemplate.metadata.provider}`)
+    );
+    console.log(chalk2.gray(`   Event: ${localTemplate.metadata.event}`));
+    console.log(chalk2.gray(`   Target: ${targetUrl}`));
+    if (secret) {
+      console.log(chalk2.gray(`   Signature: Will be generated`));
+    } else {
+      console.log(
+        chalk2.yellow(
+          `   \u26A0\uFE0F  No secret provided - signature will not be generated`
+        )
+      );
+    }
+    console.log();
+    const spinner = ora2("Sending webhook...").start();
+    try {
+      const result = await executeTemplate(localTemplate.template, {
+        url: targetUrl,
+        secret,
+        headers: options?.header
+      });
+      spinner.stop();
+      const statusColor = result.status >= 200 && result.status < 300 ? chalk2.green : result.status >= 400 ? chalk2.red : chalk2.yellow;
+      console.log(chalk2.bold("\u{1F4E5} Response\n"));
+      console.log(
+        `   Status: ${statusColor(`${result.status} ${result.statusText}`)}`
+      );
+      console.log(`   Duration: ${chalk2.cyan(`${result.duration}ms`)}`);
+      if (options?.verbose) {
+        console.log(chalk2.bold("\n   Headers:"));
+        for (const [key, value] of Object.entries(result.headers)) {
+          const headerValue = Array.isArray(value) ? value.join(", ") : value;
+          console.log(chalk2.gray(`     ${key}: ${headerValue}`));
         }
-        writeFileSync(destPath, JSON.stringify(json, null, 2));
-        console.log(`Downloaded ${templateName} -> .webhooks/${fileName}`);
-      } catch (e) {
-        console.error(`Error downloading ${templateName}: ${e.message}`);
       }
+      if (result.json !== void 0) {
+        console.log(chalk2.bold("\n   Body:"));
+        console.log(
+          chalk2.gray(
+            JSON.stringify(result.json, null, 2).split("\n").map((l) => `     ${l}`).join("\n")
+          )
+        );
+      } else if (result.bodyText) {
+        console.log(chalk2.bold("\n   Body:"));
+        const preview = result.bodyText.length > 500 ? result.bodyText.slice(0, 500) + "..." : result.bodyText;
+        console.log(chalk2.gray(`     ${preview}`));
+      }
+      console.log();
+      if (result.status >= 200 && result.status < 300) {
+        console.log(chalk2.green("\u2713 Webhook delivered successfully\n"));
+      } else {
+        console.log(
+          chalk2.yellow(`\u26A0 Webhook delivered with status ${result.status}
+`)
+        );
+      }
+    } catch (error) {
+      spinner.fail("Request failed");
+      console.error(chalk2.red(`
+\u274C ${error.message}
+`));
+      process.exitCode = 1;
     }
   }
 );
-var webhooks = new Command().name("webhooks").description("Manage and execute webhook definitions").addCommand(listCommand).addCommand(runCommand).addCommand(downloadCommand);
 
 // src/commands/capture.ts
-import { Command as Command2 } from "commander";
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join5, resolve as resolve3 } from "path";
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
 
-// src/capture.ts
-import { createServer } from "http";
-import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
-import { join as join3 } from "path";
+// src/core/capture-server.ts
+import {
+  createServer
+} from "http";
+import { WebSocketServer } from "ws";
+import {
+  writeFileSync as writeFileSync2,
+  mkdirSync as mkdirSync2,
+  existsSync as existsSync2,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync2,
+  unlinkSync as unlinkSync2
+} from "fs";
+import { join as join2 } from "path";
 import { randomUUID } from "crypto";
-var WebhookCaptureServer = class {
+import { homedir as homedir2 } from "os";
+var CaptureServer = class {
   server = null;
+  wss = null;
   capturesDir;
-  constructor(capturesDir) {
-    this.capturesDir = capturesDir;
-    if (!existsSync2(capturesDir)) {
-      mkdirSync2(capturesDir, { recursive: true });
-    }
-  }
-  start(startPort = 3001, maxAttempts = 20) {
-    return new Promise((resolve4, reject) => {
-      if (!Number.isInteger(startPort) || startPort < 0 || startPort > 65535) {
-        startPort = 3001;
-      }
-      let attempt = 0;
-      const tryListen = (portToTry) => {
-        this.server = createServer(
-          async (req, res) => {
-            try {
-              await this.handleRequest(req, res);
-            } catch (error) {
-              console.error("Error handling request:", error);
-              res.statusCode = 500;
-              res.end("Internal Server Error");
+  clients = /* @__PURE__ */ new Set();
+  captureCount = 0;
+  enableWebSocket;
+  onCapture;
+  constructor(options) {
+    const capturesDir = typeof options === "string" ? options : options?.capturesDir;
+    this.capturesDir = capturesDir || join2(homedir2(), ".better-webhook", "captures");
+    this.enableWebSocket = typeof options === "object" ? options?.enableWebSocket !== false : true;
+    this.onCapture = typeof options === "object" ? options?.onCapture : void 0;
+    if (!existsSync2(this.capturesDir)) {
+      mkdirSync2(this.capturesDir, { recursive: true });
+    }
+  }
+  /**
+   * Get the captures directory path
+   */
+  getCapturesDir() {
+    return this.capturesDir;
+  }
+  /**
+   * Start the capture server
+   */
+  async start(port = 3001, host = "0.0.0.0") {
+    return new Promise((resolve, reject) => {
+      this.server = createServer((req, res) => this.handleRequest(req, res));
+      if (this.enableWebSocket) {
+        this.wss = new WebSocketServer({ server: this.server });
+        this.wss.on("connection", (ws) => {
+          this.clients.add(ws);
+          console.log("\u{1F4E1} Dashboard connected via WebSocket");
+          ws.on("close", () => {
+            this.clients.delete(ws);
+            console.log("\u{1F4E1} Dashboard disconnected");
+          });
+          ws.on("error", (error) => {
+            console.error("WebSocket error:", error);
+            this.clients.delete(ws);
+          });
+          this.sendToClient(ws, {
+            type: "captures_updated",
+            payload: {
+              captures: this.listCaptures(),
+              count: this.captureCount
             }
-          }
+          });
+        });
+      }
+      this.server.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+          reject(new Error(`Port ${port} is already in use`));
+        } else {
+          reject(err);
+        }
+      });
+      this.server.listen(port, host, () => {
+        const address = this.server?.address();
+        const actualPort = typeof address === "object" ? address?.port || port : port;
+        console.log(`
+\u{1F3A3} Webhook Capture Server`);
+        console.log(
+          `   Listening on http://${host === "0.0.0.0" ? "localhost" : host}:${actualPort}`
         );
-        const onError = (err) => {
-          this.server?.off("error", onError);
-          this.server?.off("listening", onListening);
-          if (err && err.code === "EADDRINUSE") {
-            attempt += 1;
-            if (startPort === 0) {
-              reject(new Error("Failed to bind to an ephemeral port."));
-              return;
-            }
-            if (attempt >= maxAttempts) {
-              reject(
-                new Error(
-                  `All ${maxAttempts} port attempts starting at ${startPort} are in use.`
-                )
-              );
-              return;
-            }
-            const nextPort = startPort + attempt;
-            tryListen(nextPort);
-          } else {
-            reject(err);
-          }
-        };
-        const onListening = () => {
-          this.server?.off("error", onError);
-          this.server?.off("listening", onListening);
-          const address = this.server?.address();
-          const actualPort = address?.port ?? portToTry;
-          console.log(
-            `\u{1F3A3} Webhook capture server running on http://localhost:${actualPort}`
-          );
-          console.log(
-            `\u{1F4C1} Captured webhooks will be saved to: ${this.capturesDir}`
-          );
-          console.log(
-            "\u{1F4A1} Send webhooks to any path on this server to capture them"
-          );
-          console.log("\u23F9\uFE0F  Press Ctrl+C to stop the server");
-          resolve4(actualPort);
-        };
-        this.server.on("error", onError);
-        this.server.on("listening", onListening);
-        this.server.listen(portToTry);
-      };
-      tryListen(startPort === 0 ? 0 : startPort);
+        console.log(`   \u{1F4C1} Captures saved to: ${this.capturesDir}`);
+        console.log(`   \u{1F4A1} Send webhooks to any path to capture them`);
+        if (this.enableWebSocket) {
+          console.log(`   \u{1F310} WebSocket available for real-time updates`);
+        }
+        console.log(`   \u23F9\uFE0F  Press Ctrl+C to stop
+`);
+        resolve(actualPort);
+      });
     });
   }
-  stop() {
-    return new Promise((resolve4) => {
+  /**
+   * Stop the capture server
+   */
+  async stop() {
+    return new Promise((resolve) => {
+      for (const client of this.clients) {
+        client.close();
+      }
+      this.clients.clear();
+      if (this.wss) {
+        this.wss.close();
+        this.wss = null;
+      }
       if (this.server) {
         this.server.close(() => {
-          console.log("\u{1F4F4} Webhook capture server stopped");
-          resolve4();
+          console.log("\n\u{1F6D1} Capture server stopped");
+          resolve();
         });
       } else {
-        resolve4();
+        resolve();
       }
     });
   }
+  /**
+   * Handle incoming HTTP requests
+   */
   async handleRequest(req, res) {
+    if (req.headers.upgrade?.toLowerCase() === "websocket") {
+      return;
+    }
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const id = this.generateId();
+    const id = randomUUID();
     const url = req.url || "/";
     const urlParts = new URL(url, `http://${req.headers.host || "localhost"}`);
     const query = {};
@@ -491,299 +1313,659 @@ var WebhookCaptureServer = class {
       }
     }
     const chunks = [];
-    req.on("data", (chunk) => chunks.push(chunk));
-    await new Promise((resolve4) => {
-      req.on("end", () => resolve4());
-    });
+    for await (const chunk of req) {
+      chunks.push(chunk);
+    }
     const rawBody = Buffer.concat(chunks).toString("utf8");
-    let parsedBody;
-    try {
-      parsedBody = rawBody ? JSON.parse(rawBody) : null;
-    } catch {
-      parsedBody = rawBody || null;
+    let body = null;
+    const contentType = req.headers["content-type"] || "";
+    if (rawBody) {
+      if (contentType.includes("application/json")) {
+        try {
+          body = JSON.parse(rawBody);
+        } catch {
+          body = rawBody;
+        }
+      } else if (contentType.includes("application/x-www-form-urlencoded")) {
+        body = Object.fromEntries(new URLSearchParams(rawBody));
+      } else {
+        body = rawBody;
+      }
     }
+    const provider = this.detectProvider(req.headers);
     const captured = {
       id,
       timestamp,
       method: req.method || "GET",
-      url: urlParts.pathname,
+      url,
+      path: urlParts.pathname,
       headers: req.headers,
-      body: parsedBody,
+      body,
       rawBody,
-      query
+      query,
+      provider,
+      contentType: contentType || void 0,
+      contentLength: rawBody.length
     };
-    const filename = `${timestamp.replace(/[:.]/g, "-")}_${id}.json`;
-    const filepath = join3(this.capturesDir, filename);
+    const date = new Date(timestamp);
+    const dateStr = date.toISOString().split("T")[0];
+    const timeStr = date.toISOString().split("T")[1]?.replace(/[:.]/g, "-").slice(0, 8);
+    const filename = `${dateStr}_${timeStr}_${id.slice(0, 8)}.json`;
+    const filepath = join2(this.capturesDir, filename);
     try {
       writeFileSync2(filepath, JSON.stringify(captured, null, 2));
+      this.captureCount++;
+      const providerStr = provider ? ` [${provider}]` : "";
       console.log(
-        `\u{1F4E6} Captured ${req.method} ${urlParts.pathname} -> ${filename}`
+        `\u{1F4E6} ${req.method} ${urlParts.pathname}${providerStr} -> ${filename}`
       );
+      this.onCapture?.({ file: filename, capture: captured });
+      if (this.enableWebSocket) {
+        this.broadcast({
+          type: "capture",
+          payload: {
+            file: filename,
+            capture: captured
+          }
+        });
+      }
     } catch (error) {
-      console.error(`\u274C Failed to save capture: ${error}`);
+      console.error(`\u274C Failed to save capture:`, error);
     }
     res.statusCode = 200;
     res.setHeader("Content-Type", "application/json");
+    res.setHeader("X-Capture-Id", id);
     res.end(
-      JSON.stringify(
-        {
-          message: "Webhook captured successfully",
-          id,
-          timestamp,
-          file: filename
-        },
-        null,
-        2
-      )
+      JSON.stringify({
+        success: true,
+        message: "Webhook captured successfully",
+        id,
+        timestamp,
+        file: filename
+      })
     );
   }
-  generateId() {
+  /**
+   * Detect webhook provider from headers
+   */
+  detectProvider(headers) {
+    if (headers["stripe-signature"]) {
+      return "stripe";
+    }
+    if (headers["x-github-event"] || headers["x-hub-signature-256"]) {
+      return "github";
+    }
+    if (headers["x-ragie-delivery"]) {
+      return "ragie";
+    }
+    if (headers["x-shopify-hmac-sha256"] || headers["x-shopify-topic"]) {
+      return "shopify";
+    }
+    if (headers["x-twilio-signature"]) {
+      return "twilio";
+    }
+    if (headers["x-twilio-email-event-webhook-signature"]) {
+      return "sendgrid";
+    }
+    if (headers["x-slack-signature"]) {
+      return "slack";
+    }
+    if (headers["x-signature-ed25519"]) {
+      return "discord";
+    }
+    if (headers["linear-signature"]) {
+      return "linear";
+    }
+    if (headers["svix-signature"]) {
+      return "clerk";
+    }
+    return void 0;
+  }
+  /**
+   * Broadcast message to all connected WebSocket clients
+   */
+  broadcast(message) {
+    const data = JSON.stringify(message);
+    for (const client of this.clients) {
+      if (client.readyState === 1) {
+        client.send(data);
+      }
+    }
+  }
+  /**
+   * Send message to a specific client
+   */
+  sendToClient(client, message) {
+    if (client.readyState === 1) {
+      client.send(JSON.stringify(message));
+    }
+  }
+  /**
+   * List all captured webhooks
+   */
+  listCaptures(limit = 100) {
+    if (!existsSync2(this.capturesDir)) {
+      return [];
+    }
+    const files = readdirSync2(this.capturesDir).filter((f) => f.endsWith(".json")).sort().reverse().slice(0, limit);
+    const captures2 = [];
+    for (const file of files) {
+      try {
+        const content = readFileSync2(join2(this.capturesDir, file), "utf-8");
+        const capture2 = JSON.parse(content);
+        captures2.push({ file, capture: capture2 });
+      } catch {
+      }
+    }
+    return captures2;
+  }
+  /**
+   * Get a specific capture by ID
+   */
+  getCapture(captureId) {
+    const captures2 = this.listCaptures(1e3);
+    return captures2.find(
+      (c) => c.capture.id === captureId || c.file.includes(captureId)
+    ) || null;
+  }
+  /**
+   * Delete a capture
+   */
+  deleteCapture(captureId) {
+    const capture2 = this.getCapture(captureId);
+    if (!capture2) {
+      return false;
+    }
     try {
-      return randomUUID();
+      unlinkSync2(join2(this.capturesDir, capture2.file));
+      return true;
     } catch {
-      return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+      return false;
     }
   }
+  /**
+   * Get connected client count
+   */
+  getClientCount() {
+    return this.clients.size;
+  }
 };
 
-// src/replay.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { join as join4 } from "path";
-var WebhookReplayer = class {
+// src/commands/capture.ts
+var capture = new Command3().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(chalk3.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(chalk3.red(`Failed to start server: ${error.message}`));
+    process.exitCode = 1;
+  }
+});
+
+// src/commands/captures.ts
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+import prompts3 from "prompts";
+
+// src/core/replay-engine.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync3, unlinkSync as unlinkSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+var ReplayEngine = class {
+  capturesDir;
   constructor(capturesDir) {
-    this.capturesDir = capturesDir;
+    this.capturesDir = capturesDir || join3(homedir3(), ".better-webhook", "captures");
+  }
+  /**
+   * Get the captures directory
+   */
+  getCapturesDir() {
+    return this.capturesDir;
   }
   /**
    * List all captured webhooks
    */
-  listCaptured() {
-    try {
-      const files = listJsonFiles(this.capturesDir).sort().reverse();
-      return files.map((file) => ({
-        file,
-        capture: this.loadCapture(join4(this.capturesDir, file))
-      }));
-    } catch {
+  listCaptures(limit = 100) {
+    if (!existsSync3(this.capturesDir)) {
       return [];
     }
+    const files = readdirSync3(this.capturesDir).filter((f) => f.endsWith(".json")).sort().reverse().slice(0, limit);
+    const captures2 = [];
+    for (const file of files) {
+      try {
+        const content = readFileSync3(join3(this.capturesDir, file), "utf-8");
+        const capture2 = JSON.parse(content);
+        captures2.push({ file, capture: capture2 });
+      } catch {
+      }
+    }
+    return captures2;
+  }
+  /**
+   * Get a specific capture by ID or partial filename
+   */
+  getCapture(captureId) {
+    const captures2 = this.listCaptures(1e3);
+    let found = captures2.find((c) => c.capture.id === captureId);
+    if (found) return found;
+    found = captures2.find((c) => c.file.includes(captureId));
+    if (found) return found;
+    found = captures2.find((c) => c.capture.id.startsWith(captureId));
+    return found || null;
+  }
+  /**
+   * Replay a captured webhook
+   */
+  async replay(captureId, options) {
+    const captureFile = this.getCapture(captureId);
+    if (!captureFile) {
+      throw new Error(`Capture not found: ${captureId}`);
+    }
+    const { capture: capture2 } = captureFile;
+    const headers = [];
+    const skipHeaders = [
+      "host",
+      "content-length",
+      "connection",
+      "accept-encoding"
+    ];
+    for (const [key, value] of Object.entries(capture2.headers)) {
+      if (!skipHeaders.includes(key.toLowerCase())) {
+        const headerValue = Array.isArray(value) ? value.join(", ") : value;
+        if (headerValue) {
+          headers.push({ key, value: headerValue });
+        }
+      }
+    }
+    if (options.headers) {
+      for (const h of options.headers) {
+        const existingIdx = headers.findIndex(
+          (eh) => eh.key.toLowerCase() === h.key.toLowerCase()
+        );
+        if (existingIdx >= 0) {
+          headers[existingIdx] = h;
+        } else {
+          headers.push(h);
+        }
+      }
+    }
+    const body = capture2.rawBody || capture2.body;
+    return executeWebhook({
+      url: options.targetUrl,
+      method: options.method || capture2.method,
+      headers,
+      body
+    });
+  }
+  /**
+   * Convert a capture to a template
+   */
+  captureToTemplate(captureId, options) {
+    const captureFile = this.getCapture(captureId);
+    if (!captureFile) {
+      throw new Error(`Capture not found: ${captureId}`);
+    }
+    const { capture: capture2 } = captureFile;
+    const skipHeaders = [
+      "host",
+      "content-length",
+      "connection",
+      "accept-encoding",
+      "stripe-signature",
+      "x-hub-signature-256",
+      "x-hub-signature",
+      "x-shopify-hmac-sha256",
+      "x-twilio-signature",
+      "x-slack-signature",
+      "svix-signature",
+      "linear-signature"
+    ];
+    const headers = [];
+    for (const [key, value] of Object.entries(capture2.headers)) {
+      if (!skipHeaders.includes(key.toLowerCase())) {
+        const headerValue = Array.isArray(value) ? value.join(", ") : value;
+        if (headerValue) {
+          headers.push({ key, value: headerValue });
+        }
+      }
+    }
+    let body;
+    if (capture2.body) {
+      body = capture2.body;
+    } else if (capture2.rawBody) {
+      try {
+        body = JSON.parse(capture2.rawBody);
+      } catch {
+        body = capture2.rawBody;
+      }
+    }
+    return {
+      url: options?.url || `http://localhost:3000${capture2.path}`,
+      method: capture2.method,
+      headers,
+      body,
+      provider: capture2.provider,
+      description: `Captured ${capture2.provider || "webhook"} at ${capture2.timestamp}`
+    };
   }
   /**
-   * Load a specific captured webhook by filename or ID
+   * Get a summary of a capture
    */
-  loadCapture(filePathOrId) {
-    let filepath;
-    if (filePathOrId.includes("/") || filePathOrId.endsWith(".json")) {
-      filepath = filePathOrId;
-    } else {
-      const files = listJsonFiles(this.capturesDir).filter(
-        (f) => f.includes(filePathOrId)
-      );
-      if (files.length === 0) {
-        throw new Error(`No capture found with ID: ${filePathOrId}`);
-      }
-      if (files.length > 1) {
-        throw new Error(
-          `Multiple captures found with ID ${filePathOrId}: ${files.join(", ")}`
-        );
-      }
-      filepath = join4(this.capturesDir, files[0] ?? "");
+  getCaptureSummary(captureId) {
+    const captureFile = this.getCapture(captureId);
+    if (!captureFile) {
+      return "Capture not found";
     }
-    try {
-      const content = readFileSync2(filepath, "utf8");
-      return JSON.parse(content);
-    } catch (error) {
-      throw new Error(
-        `Failed to load capture from ${filepath}: ${error.message}`
-      );
+    const { capture: capture2 } = captureFile;
+    const lines = [];
+    lines.push(`ID: ${capture2.id}`);
+    lines.push(`Timestamp: ${new Date(capture2.timestamp).toLocaleString()}`);
+    lines.push(`Method: ${capture2.method}`);
+    lines.push(`Path: ${capture2.path}`);
+    if (capture2.provider) {
+      lines.push(`Provider: ${capture2.provider}`);
     }
+    lines.push(`Content-Type: ${capture2.contentType || "unknown"}`);
+    lines.push(`Body Size: ${capture2.contentLength || 0} bytes`);
+    const headerCount = Object.keys(capture2.headers).length;
+    lines.push(`Headers: ${headerCount}`);
+    return lines.join("\n");
   }
   /**
-   * Replay a captured webhook to a target URL
+   * Search captures
    */
-  async replay(captureId, targetUrl, options = {}) {
-    const capture2 = this.loadCapture(captureId);
-    const webhookDef = {
-      url: options.url || targetUrl,
-      method: options.method || capture2.method,
-      headers: options.headers || this.convertHeaders(capture2.headers),
-      body: capture2.body
-    };
-    console.log(`\u{1F504} Replaying webhook ${capture2.id} (${capture2.timestamp})`);
-    console.log(`   Method: ${webhookDef.method}`);
-    console.log(`   URL: ${webhookDef.url}`);
-    console.log(`   Original: ${capture2.method} ${capture2.url}`);
-    try {
-      const result = await executeWebhook(webhookDef);
-      return result;
-    } catch (error) {
-      throw new Error(`Replay failed: ${error.message}`);
-    }
+  searchCaptures(query) {
+    const queryLower = query.toLowerCase();
+    const captures2 = this.listCaptures(1e3);
+    return captures2.filter((c) => {
+      const { capture: capture2 } = c;
+      return capture2.id.toLowerCase().includes(queryLower) || capture2.path.toLowerCase().includes(queryLower) || capture2.method.toLowerCase().includes(queryLower) || capture2.provider?.toLowerCase().includes(queryLower) || c.file.toLowerCase().includes(queryLower);
+    });
   }
   /**
-   * Convert captured webhook to template format
+   * Get captures by provider
    */
-  captureToTemplate(captureId, templateUrl) {
-    const capture2 = this.loadCapture(captureId);
-    return {
-      url: templateUrl || "http://localhost:3000/webhook",
-      method: capture2.method,
-      headers: this.convertHeaders(capture2.headers),
-      body: capture2.body
-    };
+  getCapturesByProvider(provider) {
+    const captures2 = this.listCaptures(1e3);
+    return captures2.filter((c) => c.capture.provider === provider);
   }
   /**
-   * Convert captured headers to template format
+   * Delete a specific capture by ID
+   * @returns true if deleted, false if not found
    */
-  convertHeaders(headers) {
-    const result = [];
-    for (const [key, value] of Object.entries(headers)) {
-      const skipHeaders = [
-        "host",
-        "content-length",
-        "connection",
-        "accept-encoding",
-        "user-agent",
-        "x-forwarded-for",
-        "x-forwarded-proto"
-      ];
-      if (skipHeaders.includes(key.toLowerCase())) {
-        continue;
-      }
-      if (Array.isArray(value)) {
-        if (value.length === 1) {
-          result.push({ key, value: value[0] ?? "" });
-        } else {
-          result.push({ key, value: value.join(", ") });
-        }
-      } else {
-        result.push({ key, value });
-      }
+  deleteCapture(captureId) {
+    const captureFile = this.getCapture(captureId);
+    if (!captureFile) {
+      return false;
+    }
+    try {
+      unlinkSync3(join3(this.capturesDir, captureFile.file));
+      return true;
+    } catch {
+      return false;
     }
-    return result;
   }
   /**
-   * Get summary information about a capture
+   * Delete all captures
+   * @returns Number of captures deleted
    */
-  getCaptureSummary(captureId) {
-    const capture2 = this.loadCapture(captureId);
-    const date = new Date(capture2.timestamp);
-    const bodySize = capture2.rawBody ? capture2.rawBody.length : 0;
-    const headerCount = Object.keys(capture2.headers).length;
-    return [
-      `ID: ${capture2.id}`,
-      `Date: ${date.toLocaleString()}`,
-      `Method: ${capture2.method}`,
-      `Path: ${capture2.url}`,
-      `Headers: ${headerCount}`,
-      `Body Size: ${bodySize} bytes`,
-      `Query Params: ${Object.keys(capture2.query).length}`
-    ].join("\n");
+  deleteAllCaptures() {
+    if (!existsSync3(this.capturesDir)) {
+      return 0;
+    }
+    const files = readdirSync3(this.capturesDir).filter(
+      (f) => f.endsWith(".json")
+    );
+    let deleted = 0;
+    for (const file of files) {
+      try {
+        unlinkSync3(join3(this.capturesDir, file));
+        deleted++;
+      } catch {
+      }
+    }
+    return deleted;
   }
 };
+var instance2 = null;
+function getReplayEngine(capturesDir) {
+  if (!instance2) {
+    instance2 = new ReplayEngine(capturesDir);
+  }
+  return instance2;
+}
 
-// src/commands/capture.ts
-var listCommand2 = new Command2().name("list").description("List captured webhook requests").option("-l, --limit <limit>", "Maximum number of captures to show", "10").action((options) => {
-  const cwd = process.cwd();
-  const capturesDir = findCapturesDir(cwd);
-  const replayer = new WebhookReplayer(capturesDir);
-  const captures = replayer.listCaptured();
+// src/commands/captures.ts
+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 (Number.isNaN(limit) || limit <= 0) {
-    console.error("Invalid --limit: must be a positive integer.");
+  if (isNaN(limit) || limit <= 0) {
+    console.error(chalk4.red("Invalid limit value"));
     process.exitCode = 1;
     return;
   }
-  if (captures.length === 0) {
-    console.log("No webhook captures found.");
-    console.log(`Run 'better-webhook capture' to start capturing webhooks.`);
+  const engine = getReplayEngine();
+  let captures2 = engine.listCaptures(limit);
+  if (options.provider) {
+    captures2 = captures2.filter(
+      (c) => c.capture.provider?.toLowerCase() === options.provider?.toLowerCase()
+    );
+  }
+  if (captures2.length === 0) {
+    console.log(chalk4.yellow("\n\u{1F4ED} No captured webhooks found."));
+    console.log(
+      chalk4.gray("   Start capturing with: better-webhook capture\n")
+    );
+    return;
+  }
+  console.log(chalk4.bold("\n\u{1F4E6} Captured Webhooks\n"));
+  for (const { file, capture: capture2 } of captures2) {
+    const date = new Date(capture2.timestamp).toLocaleString();
+    const provider = capture2.provider ? chalk4.cyan(`[${capture2.provider}]`) : chalk4.gray("[unknown]");
+    const size = capture2.contentLength || capture2.rawBody?.length || 0;
+    console.log(`  ${chalk4.white(capture2.id.slice(0, 8))} ${provider}`);
+    console.log(chalk4.gray(`    ${capture2.method} ${capture2.path}`));
+    console.log(chalk4.gray(`    ${date} | ${size} bytes`));
+    console.log(chalk4.gray(`    File: ${file}`));
+    console.log();
+  }
+  console.log(chalk4.gray(`  Showing ${captures2.length} captures`));
+  console.log(chalk4.gray(`  Storage: ${engine.getCapturesDir()}
+`));
+});
+var showCommand = new Command4().name("show").argument("<captureId>", "Capture ID or partial ID").description("Show detailed information about a capture").option("-b, --body", "Show full body content").action((captureId, options) => {
+  const engine = getReplayEngine();
+  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 Details\n"));
+  console.log(`  ${chalk4.gray("ID:")} ${capture2.id}`);
+  console.log(`  ${chalk4.gray("File:")} ${captureFile.file}`);
   console.log(
-    `\u{1F4CB} Found ${captures.length} captured webhooks (showing ${Math.min(limit, captures.length)}):
-`
+    `  ${chalk4.gray("Timestamp:")} ${new Date(capture2.timestamp).toLocaleString()}`
   );
-  captures.slice(0, limit).forEach(({ file, capture: capture2 }) => {
-    const date = new Date(capture2.timestamp).toLocaleString();
-    const bodySize = capture2.rawBody ? capture2.rawBody.length : 0;
-    console.log(`\u{1F194} ${capture2.id} | \u{1F4C5} ${date}`);
-    console.log(`   ${capture2.method} ${capture2.url} | ${bodySize} bytes`);
-    console.log(`   \u{1F4C4} ${file}
-`);
-  });
-  if (captures.length > limit) {
+  console.log(`  ${chalk4.gray("Method:")} ${capture2.method}`);
+  console.log(`  ${chalk4.gray("Path:")} ${capture2.path}`);
+  console.log(`  ${chalk4.gray("URL:")} ${capture2.url}`);
+  if (capture2.provider) {
     console.log(
-      `... and ${captures.length - limit} more. Use --limit to show more.`
+      `  ${chalk4.gray("Provider:")} ${chalk4.cyan(capture2.provider)}`
     );
   }
-});
-var templateCommand = new Command2().name("template").argument("<captureId>", "ID of the captured webhook to create template from").argument("[templateName]", "Name for the generated template").description("Generate a webhook template from a captured request").option(
-  "-u, --url <url>",
-  "Template URL (default: http://localhost:3000/webhook)"
-).option("-o, --output-dir <dir>", "Output directory (default: .webhooks)").action(
-  async (captureId, templateName, options) => {
-    const cwd = process.cwd();
-    const capturesDir = findCapturesDir(cwd);
-    const replayer = new WebhookReplayer(capturesDir);
-    try {
-      const template = replayer.captureToTemplate(captureId, options?.url);
-      if (!templateName) {
-        const capture2 = replayer.loadCapture(captureId);
-        const date = new Date(capture2.timestamp).toISOString().split("T")[0];
-        const pathPart = capture2.url.replace(/[^a-zA-Z0-9]/g, "_").substring(1) || "webhook";
-        templateName = `captured_${date}_${pathPart}_${capture2.id}`;
-      }
-      const outputDir = options?.outputDir ? resolve3(cwd, options.outputDir) : findWebhooksDir(cwd);
-      mkdirSync3(outputDir, { recursive: true });
-      const templatePath = join5(outputDir, `${templateName}.json`);
-      writeFileSync3(templatePath, JSON.stringify(template, null, 2));
-      console.log(`\u2705 Template created: ${templatePath}`);
+  console.log(
+    `  ${chalk4.gray("Content-Type:")} ${capture2.contentType || "unknown"}`
+  );
+  console.log(
+    `  ${chalk4.gray("Content-Length:")} ${capture2.contentLength || 0} bytes`
+  );
+  const queryKeys = Object.keys(capture2.query);
+  if (queryKeys.length > 0) {
+    console.log(chalk4.bold("\n  Query Parameters:"));
+    for (const [key, value] of Object.entries(capture2.query)) {
+      const queryValue = Array.isArray(value) ? value.join(", ") : value;
+      console.log(chalk4.gray(`    ${key}: ${queryValue}`));
+    }
+  }
+  console.log(chalk4.bold("\n  Headers:"));
+  for (const [key, value] of Object.entries(capture2.headers)) {
+    const headerValue = Array.isArray(value) ? value.join(", ") : value;
+    const display = headerValue.length > 80 ? headerValue.slice(0, 80) + "..." : headerValue;
+    console.log(chalk4.gray(`    ${key}: ${display}`));
+  }
+  if (options.body && capture2.body) {
+    console.log(chalk4.bold("\n  Body:"));
+    if (typeof capture2.body === "object") {
       console.log(
-        `\u{1F504} Run it with: better-webhook webhooks run ${templateName}`
+        chalk4.gray(
+          JSON.stringify(capture2.body, null, 2).split("\n").map((l) => `    ${l}`).join("\n")
+        )
       );
-      console.log("\n\u{1F4CA} Template Summary:");
-      console.log(replayer.getCaptureSummary(captureId));
-    } catch (error) {
-      console.error("\u274C Template generation failed:", error.message);
-      process.exitCode = 1;
+    } else {
+      console.log(chalk4.gray(`    ${capture2.body}`));
     }
+  } else if (capture2.body) {
+    console.log(chalk4.bold("\n  Body:"));
+    const preview = JSON.stringify(capture2.body).slice(0, 200);
+    console.log(
+      chalk4.gray(`    ${preview}${preview.length >= 200 ? "..." : ""}`)
+    );
+    console.log(chalk4.gray("    Use --body to see full content"));
   }
-);
-var capture = new Command2().name("capture").description(
-  "Start a server to capture incoming webhook requests, or list captured webhooks"
-).option("-p, --port <port>", "Port to listen on", "3001").action(async (options) => {
-  const cwd = process.cwd();
-  const capturesDir = findCapturesDir(cwd);
-  const server = new WebhookCaptureServer(capturesDir);
-  let actualPort;
-  try {
-    actualPort = await server.start(parseInt(options.port));
-  } catch (error) {
-    console.error("Failed to start capture server:", error.message);
+  console.log();
+});
+var searchCommand2 = new Command4().name("search").argument("<query>", "Search query").description("Search captures by path, method, or provider").action((query) => {
+  const engine = getReplayEngine();
+  const results = engine.searchCaptures(query);
+  if (results.length === 0) {
+    console.log(chalk4.yellow(`
+\u{1F4ED} No captures found for: "${query}"
+`));
+    return;
+  }
+  console.log(chalk4.bold(`
+\u{1F50D} Search Results for "${query}"
+`));
+  for (const { file, capture: capture2 } of results) {
+    const date = new Date(capture2.timestamp).toLocaleString();
+    const provider = capture2.provider ? chalk4.cyan(`[${capture2.provider}]`) : "";
+    console.log(`  ${chalk4.white(capture2.id.slice(0, 8))} ${provider}`);
+    console.log(chalk4.gray(`    ${capture2.method} ${capture2.path}`));
+    console.log(chalk4.gray(`    ${date}`));
+    console.log();
+  }
+  console.log(chalk4.gray(`  Found: ${results.length} captures
+`));
+});
+var deleteCommand = new Command4().name("delete").alias("rm").argument("<captureId>", "Capture ID or partial ID to delete").description("Delete a specific captured webhook").option("-f, --force", "Skip confirmation prompt").action(async (captureId, options) => {
+  const engine = getReplayEngine();
+  const captureFile = engine.getCapture(captureId);
+  if (!captureFile) {
+    console.log(chalk4.red(`
+\u274C Capture not found: ${captureId}
+`));
     process.exitCode = 1;
     return;
   }
-  const shutdown = async () => {
-    console.log("\n\u{1F6D1} Shutting down server...");
-    await server.stop();
-    process.exit(0);
-  };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-}).addCommand(listCommand2).addCommand(templateCommand);
+  const { capture: capture2 } = captureFile;
+  if (!options.force) {
+    console.log(chalk4.bold("\n\u{1F5D1}\uFE0F  Capture to delete:\n"));
+    console.log(`    ${chalk4.white(capture2.id.slice(0, 8))}`);
+    console.log(chalk4.gray(`    ${capture2.method} ${capture2.path}`));
+    console.log(
+      chalk4.gray(`    ${new Date(capture2.timestamp).toLocaleString()}`)
+    );
+    console.log();
+    const response = await prompts3({
+      type: "confirm",
+      name: "confirm",
+      message: "Delete this capture?",
+      initial: false
+    });
+    if (!response.confirm) {
+      console.log(chalk4.yellow("Cancelled"));
+      return;
+    }
+  }
+  const deleted = engine.deleteCapture(captureId);
+  if (deleted) {
+    console.log(
+      chalk4.green(`
+\u2713 Deleted capture: ${capture2.id.slice(0, 8)}
+`)
+    );
+  } else {
+    console.log(chalk4.red(`
+\u274C Failed to delete capture
+`));
+    process.exitCode = 1;
+  }
+});
+var cleanCommand2 = new Command4().name("clean").alias("remove-all").description("Remove all captured webhooks").option("-f, --force", "Skip confirmation prompt").action(async (options) => {
+  const engine = getReplayEngine();
+  const captures2 = engine.listCaptures(1e4);
+  if (captures2.length === 0) {
+    console.log(chalk4.yellow("\n\u{1F4ED} No captures to remove.\n"));
+    return;
+  }
+  console.log(
+    chalk4.bold(`
+\u{1F5D1}\uFE0F  Found ${captures2.length} captured webhook(s)
+`)
+  );
+  const byProvider = /* @__PURE__ */ new Map();
+  for (const c of captures2) {
+    const provider = c.capture.provider || "unknown";
+    byProvider.set(provider, (byProvider.get(provider) || 0) + 1);
+  }
+  for (const [provider, count] of byProvider) {
+    console.log(chalk4.gray(`    ${provider}: ${count}`));
+  }
+  console.log();
+  if (!options.force) {
+    const response = await prompts3({
+      type: "confirm",
+      name: "confirm",
+      message: `Delete all ${captures2.length} capture(s)?`,
+      initial: false
+    });
+    if (!response.confirm) {
+      console.log(chalk4.yellow("Cancelled"));
+      return;
+    }
+  }
+  const deleted = engine.deleteAllCaptures();
+  console.log(chalk4.green(`
+\u2713 Removed ${deleted} capture(s)`));
+  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);
 
 // src/commands/replay.ts
-import { Command as Command3 } from "commander";
-import prompts2 from "prompts";
-import ora2 from "ora";
-var replay = new Command3().name("replay").argument(
-  "[captureId]",
-  "ID of the captured webhook to replay (optional - will prompt if not provided)"
-).argument(
-  "[targetUrl]",
-  "Target URL to replay the webhook to (optional - will prompt if not provided)"
-).description("Replay a captured webhook to a target URL").option("-m, --method <method>", "Override HTTP method").option(
+import { Command as Command5 } from "commander";
+import ora3 from "ora";
+import prompts4 from "prompts";
+import chalk5 from "chalk";
+var replay = new Command5().name("replay").argument("[captureId]", "Capture ID to replay").argument("[targetUrl]", "Target URL to replay to").description("Replay a captured webhook to a target URL").option("-m, --method <method>", "Override HTTP method").option(
   "-H, --header <header>",
-  "Add custom header (format: key:value)",
+  "Add or override header (format: key:value)",
   (value, previous) => {
     const [key, ...valueParts] = value.split(":");
     const headerValue = valueParts.join(":");
@@ -795,53 +1977,53 @@ var replay = new Command3().name("replay").argument(
     ]);
   },
   []
-).action(
-  async (captureId, targetUrl, options = {}) => {
-    const cwd = process.cwd();
-    const capturesDir = findCapturesDir(cwd);
-    const replayer = new WebhookReplayer(capturesDir);
-    const spinner = ora2("Loading captured webhooks...").start();
-    const captured = replayer.listCaptured();
-    spinner.stop();
-    if (captured.length === 0) {
-      console.log("\u{1F4ED} No captured webhooks found.");
-      console.log(
-        "\u{1F4A1} Run 'better-webhook capture' to start capturing webhooks first."
-      );
-      return;
-    }
-    let selectedCaptureId = captureId;
-    let selectedTargetUrl = targetUrl;
-    if (!selectedCaptureId) {
-      const choices = captured.map((c) => {
+).option("-v, --verbose", "Show detailed request/response information").action(
+  async (captureId, targetUrl, options) => {
+    const engine = getReplayEngine();
+    if (!captureId) {
+      const captures2 = engine.listCaptures(50);
+      if (captures2.length === 0) {
+        console.log(chalk5.yellow("\n\u{1F4ED} No captured webhooks found."));
+        console.log(
+          chalk5.gray("   Start capturing with: better-webhook capture\n")
+        );
+        return;
+      }
+      const choices = captures2.map((c) => {
         const date = new Date(c.capture.timestamp).toLocaleString();
-        const bodySize = c.capture.rawBody?.length ?? 0;
+        const provider = c.capture.provider ? `[${c.capture.provider}]` : "";
         return {
-          title: `${c.capture.id} - ${c.capture.method} ${c.capture.url}`,
-          description: `${date} | Body: ${bodySize} bytes`,
+          title: `${c.capture.id.slice(0, 8)} ${provider} ${c.capture.method} ${c.capture.path}`,
+          description: date,
           value: c.capture.id
         };
       });
-      const response = await prompts2({
+      const response = await prompts4({
         type: "select",
         name: "captureId",
-        message: "Select a captured webhook to replay:",
-        choices,
-        initial: 0
+        message: "Select a capture to replay:",
+        choices
       });
       if (!response.captureId) {
-        console.log("\u274C No webhook selected. Exiting.");
-        process.exitCode = 1;
+        console.log(chalk5.yellow("Cancelled"));
         return;
       }
-      selectedCaptureId = response.captureId;
+      captureId = response.captureId;
     }
-    if (!selectedTargetUrl) {
-      const response = await prompts2({
+    const captureFile = engine.getCapture(captureId);
+    if (!captureFile) {
+      console.log(chalk5.red(`
+\u274C Capture not found: ${captureId}
+`));
+      process.exitCode = 1;
+      return;
+    }
+    if (!targetUrl) {
+      const response = await prompts4({
         type: "text",
-        name: "targetUrl",
-        message: "Enter the target URL to replay to:",
-        initial: "http://localhost:3000/webhook",
+        name: "url",
+        message: "Enter target URL:",
+        initial: `http://localhost:3000${captureFile.capture.path}`,
         validate: (value) => {
           try {
             new URL(value);
@@ -851,43 +2033,549 @@ var replay = new Command3().name("replay").argument(
           }
         }
       });
-      if (!response.targetUrl) {
-        console.log("\u274C No target URL provided. Exiting.");
-        process.exitCode = 1;
+      if (!response.url) {
+        console.log(chalk5.yellow("Cancelled"));
         return;
       }
-      selectedTargetUrl = response.targetUrl;
+      targetUrl = response.url;
     }
+    const { capture: capture2 } = captureFile;
+    console.log(chalk5.bold("\n\u{1F504} Replaying Webhook\n"));
+    console.log(chalk5.gray(`   Capture ID: ${capture2.id.slice(0, 8)}`));
+    console.log(chalk5.gray(`   Original: ${capture2.method} ${capture2.path}`));
+    if (capture2.provider) {
+      console.log(chalk5.gray(`   Provider: ${capture2.provider}`));
+    }
+    console.log(chalk5.gray(`   Target: ${targetUrl}`));
+    console.log();
+    const spinner = ora3("Replaying webhook...").start();
     try {
-      const result = await replayer.replay(
-        selectedCaptureId,
-        selectedTargetUrl,
-        {
-          method: options.method,
-          headers: options.header
-        }
+      const result = await engine.replay(captureId, {
+        targetUrl,
+        method: options?.method,
+        headers: options?.header
+      });
+      spinner.stop();
+      const statusColor = result.status >= 200 && result.status < 300 ? chalk5.green : result.status >= 400 ? chalk5.red : chalk5.yellow;
+      console.log(chalk5.bold("\u{1F4E5} Response\n"));
+      console.log(
+        `   Status: ${statusColor(`${result.status} ${result.statusText}`)}`
       );
-      console.log("\u2705 Replay completed successfully!");
-      console.log("Status:", result.status);
-      console.log("Headers:");
-      for (const [k, v] of Object.entries(result.headers)) {
-        console.log(`  ${k}: ${Array.isArray(v) ? v.join(", ") : v}`);
+      console.log(`   Duration: ${chalk5.cyan(`${result.duration}ms`)}`);
+      if (options?.verbose) {
+        console.log(chalk5.bold("\n   Headers:"));
+        for (const [key, value] of Object.entries(result.headers)) {
+          const headerValue = Array.isArray(value) ? value.join(", ") : value;
+          console.log(chalk5.gray(`     ${key}: ${headerValue}`));
+        }
       }
       if (result.json !== void 0) {
-        console.log("Response JSON:");
-        console.log(JSON.stringify(result.json, null, 2));
+        console.log(chalk5.bold("\n   Body:"));
+        console.log(
+          chalk5.gray(
+            JSON.stringify(result.json, null, 2).split("\n").map((l) => `     ${l}`).join("\n")
+          )
+        );
+      } else if (result.bodyText) {
+        console.log(chalk5.bold("\n   Body:"));
+        const preview = result.bodyText.length > 500 ? result.bodyText.slice(0, 500) + "..." : result.bodyText;
+        console.log(chalk5.gray(`     ${preview}`));
+      }
+      console.log();
+      if (result.status >= 200 && result.status < 300) {
+        console.log(chalk5.green("\u2713 Replay completed successfully\n"));
       } else {
-        console.log("Response Body:");
-        console.log(result.bodyText);
+        console.log(
+          chalk5.yellow(`\u26A0 Replay completed with status ${result.status}
+`)
+        );
       }
     } catch (error) {
-      console.error("\u274C Replay failed:", error.message);
+      spinner.fail("Replay failed");
+      console.error(chalk5.red(`
+\u274C ${error.message}
+`));
       process.exitCode = 1;
     }
   }
 );
 
+// src/commands/dashboard.ts
+import { Command as Command6 } from "commander";
+import chalk6 from "chalk";
+
+// src/core/dashboard-server.ts
+import express2 from "express";
+import { createServer as createServer2 } from "http";
+import { WebSocketServer as WebSocketServer2 } from "ws";
+import path from "path";
+import { existsSync as existsSync4 } from "fs";
+import { fileURLToPath } from "url";
+
+// src/core/dashboard-api.ts
+import express from "express";
+import { z as z2 } from "zod";
+function jsonError(res, status, message) {
+  return res.status(status).json({ error: message });
+}
+function getSecretEnvVarName2(provider) {
+  const envVarMap = {
+    github: "GITHUB_WEBHOOK_SECRET",
+    stripe: "STRIPE_WEBHOOK_SECRET",
+    shopify: "SHOPIFY_WEBHOOK_SECRET",
+    twilio: "TWILIO_WEBHOOK_SECRET",
+    ragie: "RAGIE_WEBHOOK_SECRET",
+    slack: "SLACK_WEBHOOK_SECRET",
+    linear: "LINEAR_WEBHOOK_SECRET",
+    clerk: "CLERK_WEBHOOK_SECRET",
+    sendgrid: "SENDGRID_WEBHOOK_SECRET",
+    discord: "DISCORD_WEBHOOK_SECRET",
+    custom: "WEBHOOK_SECRET"
+  };
+  return envVarMap[provider] || "WEBHOOK_SECRET";
+}
+var ReplayBodySchema = z2.object({
+  captureId: z2.string().min(1),
+  targetUrl: z2.string().min(1),
+  method: HttpMethodSchema.optional(),
+  headers: z2.array(HeaderEntrySchema).optional()
+});
+var TemplateDownloadBodySchema = z2.object({
+  id: z2.string().min(1)
+});
+var RunTemplateBodySchema = z2.object({
+  templateId: z2.string().min(1),
+  url: z2.string().min(1),
+  secret: z2.string().optional(),
+  headers: z2.array(HeaderEntrySchema).optional()
+});
+function createDashboardApiRouter(options = {}) {
+  const router = express.Router();
+  const replayEngine = new ReplayEngine(options.capturesDir);
+  const templateManager = new TemplateManager(options.templatesBaseDir);
+  const broadcast = options.broadcast;
+  const broadcastCaptures = () => {
+    if (!broadcast) return;
+    const captures2 = replayEngine.listCaptures(200);
+    broadcast({
+      type: "captures_updated",
+      payload: { captures: captures2, count: captures2.length }
+    });
+  };
+  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 = [];
+    }
+    broadcast({
+      type: "templates_updated",
+      payload: { local, remote }
+    });
+  };
+  router.get("/captures", (req, res) => {
+    const limitRaw = typeof req.query.limit === "string" ? req.query.limit : "";
+    const providerRaw = typeof req.query.provider === "string" ? req.query.provider : "";
+    const qRaw = typeof req.query.q === "string" ? req.query.q : "";
+    const limit = limitRaw ? Number.parseInt(limitRaw, 10) : 50;
+    if (!Number.isFinite(limit) || limit <= 0 || limit > 5e3) {
+      return jsonError(res, 400, "Invalid limit");
+    }
+    const q = qRaw.trim();
+    const provider = providerRaw.trim();
+    let captures2 = q ? replayEngine.searchCaptures(q) : replayEngine.listCaptures(Math.max(limit, 1e3));
+    if (provider) {
+      captures2 = captures2.filter(
+        (c) => (c.capture.provider || "").toLowerCase() === provider.toLowerCase()
+      );
+    }
+    captures2 = captures2.slice(0, limit);
+    return res.json({ captures: captures2, count: captures2.length });
+  });
+  router.get("/captures/:id", (req, res) => {
+    const id = req.params.id;
+    if (!id) {
+      return jsonError(res, 400, "Missing capture id");
+    }
+    const captureFile = replayEngine.getCapture(id);
+    if (!captureFile) {
+      return jsonError(res, 404, "Capture not found");
+    }
+    return res.json(captureFile);
+  });
+  router.delete("/captures/:id", (req, res) => {
+    const id = req.params.id;
+    if (!id) {
+      return jsonError(res, 400, "Missing capture id");
+    }
+    const deleted = replayEngine.deleteCapture(id);
+    if (!deleted) {
+      return jsonError(res, 404, "Capture not found");
+    }
+    broadcastCaptures();
+    return res.json({ success: true });
+  });
+  router.delete("/captures", (_req, res) => {
+    const deleted = replayEngine.deleteAllCaptures();
+    broadcastCaptures();
+    return res.json({ success: true, deleted });
+  });
+  router.post("/replay", express.json({ limit: "5mb" }), async (req, res) => {
+    const parsed = ReplayBodySchema.safeParse(req.body);
+    if (!parsed.success) {
+      return jsonError(
+        res,
+        400,
+        parsed.error.issues[0]?.message || "Invalid body"
+      );
+    }
+    const { captureId, targetUrl, method, headers } = parsed.data;
+    try {
+      new URL(targetUrl);
+    } catch {
+      return jsonError(res, 400, "Invalid targetUrl");
+    }
+    try {
+      const result = await replayEngine.replay(captureId, {
+        targetUrl,
+        method,
+        headers
+      });
+      broadcast?.({
+        type: "replay_result",
+        payload: { captureId, targetUrl, result }
+      });
+      return res.json(result);
+    } catch (error) {
+      return jsonError(res, 400, error?.message || "Replay failed");
+    }
+  });
+  router.get("/templates/local", (_req, res) => {
+    const local = templateManager.listLocalTemplates();
+    return res.json({ templates: local, count: local.length });
+  });
+  router.get("/templates/remote", async (req, res) => {
+    const refresh = typeof req.query.refresh === "string" ? req.query.refresh === "1" || req.query.refresh.toLowerCase() === "true" : false;
+    try {
+      const index = await templateManager.fetchRemoteIndex(refresh);
+      const localIds = new Set(
+        templateManager.listLocalTemplates().map((t) => t.id)
+      );
+      const remote = index.templates.map((metadata) => ({
+        metadata,
+        isDownloaded: localIds.has(metadata.id)
+      }));
+      return res.json({ templates: remote, count: remote.length });
+    } catch (error) {
+      return jsonError(
+        res,
+        500,
+        error?.message || "Failed to fetch remote templates"
+      );
+    }
+  });
+  router.post(
+    "/templates/download",
+    express.json({ limit: "2mb" }),
+    async (req, res) => {
+      const parsed = TemplateDownloadBodySchema.safeParse(req.body);
+      if (!parsed.success) {
+        return jsonError(
+          res,
+          400,
+          parsed.error.issues[0]?.message || "Invalid body"
+        );
+      }
+      try {
+        const template = await templateManager.downloadTemplate(parsed.data.id);
+        void broadcastTemplates();
+        return res.json({ success: true, template });
+      } catch (error) {
+        return jsonError(res, 400, error?.message || "Download failed");
+      }
+    }
+  );
+  router.post(
+    "/templates/download-all",
+    express.json({ limit: "1mb" }),
+    async (_req, res) => {
+      try {
+        const index = await templateManager.fetchRemoteIndex(true);
+        const localIds = new Set(
+          templateManager.listLocalTemplates().map((t) => t.id)
+        );
+        const toDownload = index.templates.filter((t) => !localIds.has(t.id));
+        const downloaded = [];
+        const failed = [];
+        for (const t of toDownload) {
+          try {
+            await templateManager.downloadTemplate(t.id);
+            downloaded.push(t.id);
+          } catch (e) {
+            failed.push({ id: t.id, error: e?.message || "Failed" });
+          }
+        }
+        return res.json({
+          success: true,
+          total: index.templates.length,
+          downloaded,
+          failed
+        });
+      } catch (error) {
+        return jsonError(res, 500, error?.message || "Download-all failed");
+      }
+    }
+  );
+  router.post("/run", express.json({ limit: "10mb" }), async (req, res) => {
+    const parsed = RunTemplateBodySchema.safeParse(req.body);
+    if (!parsed.success) {
+      return jsonError(
+        res,
+        400,
+        parsed.error.issues[0]?.message || "Invalid body"
+      );
+    }
+    let { templateId, url, secret, headers } = parsed.data;
+    try {
+      new URL(url);
+    } catch {
+      return jsonError(res, 400, "Invalid url");
+    }
+    if (templateId.startsWith("remote:")) {
+      templateId = templateId.slice("remote:".length);
+      try {
+        await templateManager.downloadTemplate(templateId);
+      } catch (error) {
+        return jsonError(
+          res,
+          400,
+          error?.message || "Failed to download template"
+        );
+      }
+    }
+    let localTemplate = templateManager.getLocalTemplate(templateId);
+    if (!localTemplate) {
+      try {
+        await templateManager.downloadTemplate(templateId);
+        localTemplate = templateManager.getLocalTemplate(templateId);
+      } catch {
+      }
+    }
+    if (!localTemplate) {
+      return jsonError(res, 404, "Template not found");
+    }
+    if (!secret && localTemplate.metadata.provider) {
+      const envVarName = getSecretEnvVarName2(localTemplate.metadata.provider);
+      secret = process.env[envVarName];
+    }
+    const safeHeaders = headers?.length ? headers : void 0;
+    try {
+      const result = await executeTemplate(localTemplate.template, {
+        url,
+        secret,
+        headers: safeHeaders
+      });
+      broadcast?.({
+        type: "replay_result",
+        payload: { templateId, url, result }
+      });
+      return res.json(result);
+    } catch (error) {
+      return jsonError(res, 400, error?.message || "Run failed");
+    }
+  });
+  return router;
+}
+
+// src/core/dashboard-server.ts
+function resolveDashboardDistDir(runtimeDir) {
+  const candidates = [
+    path.resolve(runtimeDir, "..", "dashboard"),
+    path.resolve(runtimeDir, "..", "..", "dist", "dashboard"),
+    path.resolve(runtimeDir, "..", "..", "..", "dashboard", "dist")
+  ];
+  for (const distDir of candidates) {
+    const indexHtml = path.join(distDir, "index.html");
+    if (existsSync4(indexHtml)) {
+      return { distDir, indexHtml };
+    }
+  }
+  const details = candidates.map((p) => `- ${p}`).join("\n");
+  throw new Error(
+    `Dashboard UI build output not found.
+Looked in:
+${details}
+
+Build it with:
+- pnpm --filter @better-webhook/dashboard build
+- pnpm --filter @better-webhook/cli build
+`
+  );
+}
+async function startDashboardServer(options = {}) {
+  const app = express2();
+  app.get("/health", (_req, res) => {
+    res.json({ ok: true });
+  });
+  const clients = /* @__PURE__ */ new Set();
+  const broadcast = (message) => {
+    const data = JSON.stringify(message);
+    for (const client of clients) {
+      if (client.readyState === 1) {
+        client.send(data);
+      }
+    }
+  };
+  app.use(
+    "/api",
+    createDashboardApiRouter({
+      capturesDir: options.capturesDir,
+      templatesBaseDir: options.templatesBaseDir,
+      broadcast
+    })
+  );
+  const host = options.host || "localhost";
+  const port = options.port ?? 4e3;
+  const runtimeDir = (
+    // eslint-disable-next-line no-undef
+    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) => {
+    clients.add(ws);
+    ws.on("close", () => clients.delete(ws));
+    ws.on("error", () => clients.delete(ws));
+    const replayEngine = new ReplayEngine(options.capturesDir);
+    const templateManager = new TemplateManager(options.templatesBaseDir);
+    const captures2 = replayEngine.listCaptures(200);
+    ws.send(
+      JSON.stringify({
+        type: "captures_updated",
+        payload: { captures: captures2, count: captures2.length }
+      })
+    );
+    const local = templateManager.listLocalTemplates();
+    let remote = [];
+    try {
+      const index = await templateManager.fetchRemoteIndex(true);
+      const localIds = new Set(local.map((t) => t.id));
+      remote = index.templates.map((metadata) => ({
+        metadata,
+        isDownloaded: localIds.has(metadata.id)
+      }));
+    } catch {
+      remote = [];
+    }
+    ws.send(
+      JSON.stringify({
+        type: "templates_updated",
+        payload: { local, remote }
+      })
+    );
+  });
+  await new Promise((resolve, reject) => {
+    server.listen(port, host, () => resolve());
+    server.on("error", reject);
+  });
+  const url = `http://${host}:${port}`;
+  let capture2;
+  const shouldStartCapture = options.startCapture !== false;
+  if (shouldStartCapture) {
+    const captureHost = options.captureHost || "0.0.0.0";
+    const capturePort = options.capturePort ?? 3001;
+    const captureServer = new CaptureServer({
+      capturesDir: options.capturesDir,
+      enableWebSocket: false,
+      onCapture: ({ file, capture: capture3 }) => {
+        broadcast({
+          type: "capture",
+          payload: { file, capture: capture3 }
+        });
+      }
+    });
+    const actualPort = await captureServer.start(capturePort, captureHost);
+    capture2 = {
+      server: captureServer,
+      url: `http://${captureHost === "0.0.0.0" ? "localhost" : captureHost}:${actualPort}`
+    };
+  }
+  return { app, server, url, capture: capture2 };
+}
+
+// src/commands/dashboard.ts
+var dashboard = new Command6().name("dashboard").description("Start the local dashboard (UI + API + WebSocket) server").option("-p, --port <port>", "Port to listen on", "4000").option("-h, --host <host>", "Host to bind to", "localhost").option("--capture-port <port>", "Capture server port", "3001").option("--capture-host <host>", "Capture server host", "0.0.0.0").option("--no-capture", "Do not start the capture server").option("--captures-dir <dir>", "Override captures directory").option("--templates-dir <dir>", "Override templates base directory").action(async (options) => {
+  const port = Number.parseInt(String(options.port), 10);
+  if (!Number.isFinite(port) || port < 0 || port > 65535) {
+    console.error(chalk6.red("Invalid 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(chalk6.red("Invalid capture port number"));
+      process.exitCode = 1;
+      return;
+    }
+    const { url, server, capture: capture2 } = await startDashboardServer({
+      host: options.host,
+      port,
+      captureHost: options.captureHost,
+      capturePort,
+      startCapture: options.capture !== false,
+      capturesDir: options.capturesDir,
+      templatesBaseDir: options.templatesDir
+    });
+    console.log(chalk6.bold("\n\u{1F9ED} Dashboard Server\n"));
+    console.log(chalk6.gray(`   Dashboard: ${url}/`));
+    console.log(chalk6.gray(`   Health: ${url}/health`));
+    console.log(chalk6.gray(`   API Base: ${url}/api`));
+    console.log(chalk6.gray(`   WebSocket: ${url.replace("http://", "ws://")}/ws`));
+    if (capture2) {
+      console.log();
+      console.log(chalk6.bold("\u{1F3A3} Capture Server"));
+      console.log(chalk6.gray(`   Capture: ${capture2.url}`));
+      console.log(chalk6.gray(`   Tip: Send webhooks to any path, e.g. ${capture2.url}/webhooks/github`));
+    }
+    console.log();
+    const shutdown = async () => {
+      if (capture2) {
+        await capture2.server.stop();
+      }
+      await new Promise((resolve) => server.close(() => resolve()));
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  } catch (error) {
+    console.error(chalk6.red(`Failed to start dashboard server: ${error?.message || error}`));
+    process.exitCode = 1;
+  }
+});
+
 // src/index.ts
-var program = new Command4().name("better-webhook").description("CLI for listing, downloading and executing predefined webhooks").version("0.2.0");
-program.addCommand(webhooks).addCommand(capture).addCommand(replay);
+var program = new Command7().name("better-webhook").description(
+  "Modern CLI for developing, capturing, and replaying webhooks locally"
+).version("2.0.0");
+program.addCommand(templates).addCommand(run).addCommand(capture).addCommand(captures).addCommand(replay).addCommand(dashboard);
 program.parseAsync(process.argv);