@better-webhook/cli 0.3.0 → 3.0.0

package/dist/index.js

@@ -1,42 +1,37 @@
 #!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/index.ts
-import { Command as Command4 } from "commander";
+import { Command as Command6 } 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, statSync } from "fs";
-import { join, resolve, extname } from "path";
-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 [];
-  }
-}
-
-// src/loader.ts
-import { readFileSync } from "fs";
+// 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",
@@ -45,329 +40,1246 @@ 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",
+  "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/loader.ts
-function loadWebhookFile(path) {
-  let rawContent;
-  try {
-    rawContent = readFileSync(path, "utf8");
-  } catch (e) {
-    throw new Error(`Failed to read file ${path}: ${e.message}`);
+// 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 });
+    }
   }
-  let json;
-  try {
-    json = JSON.parse(rawContent);
-  } catch (e) {
-    throw new Error(`Invalid JSON in file ${path}: ${e.message}`);
+  /**
+   * Get the templates directory path
+   */
+  getTemplatesDir() {
+    return this.templatesDir;
   }
-  return validateWebhookJSON(json, path);
-}
-
-// src/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) {
+  /**
+   * 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 {
-      parsed = JSON.parse(text);
+      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() {
+    const index = await this.fetchRemoteIndex();
+    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 {
+      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))
+    };
+  }
+  /**
+   * Clear the templates cache
+   */
+  clearCache() {
+    this.indexCache = null;
+    if (existsSync(this.cacheFile)) {
+      unlinkSync(this.cacheFile);
+    }
+  }
+  /**
+   * 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;
   }
-  return {
-    status: statusCode,
-    headers: resultHeaders,
-    bodyText: text,
-    json: parsed
-  };
-}
-
-// src/commands/webhooks.ts
-import { mkdirSync, writeFileSync, existsSync } from "fs";
-import { request as request2 } from "undici";
-var TEMPLATE_REPO_BASE = "https://raw.githubusercontent.com/endalk200/better-webhook/main";
-var TEMPLATES = {
-  "stripe-invoice.payment_succeeded": "templates/stripe-invoice.payment_succeeded.json"
 };
-function statExists(p) {
-  try {
-    statSync2(p);
-    return true;
-  } catch {
-    return false;
+var instance = null;
+function getTemplateManager(baseDir) {
+  if (!instance) {
+    instance = new TemplateManager(baseDir);
   }
+  return instance;
 }
-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("No webhook definitions found in .webhooks");
-    return;
+
+// 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 {
+    const manager = getTemplateManager();
+    const templates2 = await manager.listRemoteTemplates();
+    spinner.stop();
+    if (templates2.length === 0) {
+      console.log(chalk.yellow("\u{1F4ED} No remote templates found."));
+      return;
+    }
+    let filtered = templates2;
+    if (options.provider) {
+      filtered = templates2.filter(
+        (t) => t.metadata.provider.toLowerCase() === options.provider?.toLowerCase()
+      );
+    }
+    if (filtered.length === 0) {
+      console.log(
+        chalk.yellow(
+          `\u{1F4ED} No templates found for provider: ${options.provider}`
+        )
+      );
+      return;
+    }
+    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;
   }
-  files.forEach((f) => console.log(basename(f, ".json")));
 });
-var runCommand = new Command().name("run").argument("<nameOrPath>", "Webhook name (in .webhooks) or path to JSON file").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();
-  let filePath;
-  if (nameOrPath.endsWith(".json") && !nameOrPath.includes("/") && !nameOrPath.startsWith(".")) {
-    filePath = join2(findWebhooksDir(cwd), nameOrPath);
-  } else {
-    const candidate = join2(
-      findWebhooksDir(cwd),
-      nameOrPath + (nameOrPath.endsWith(".json") ? "" : ".json")
-    );
-    if (statExists(candidate)) {
-      filePath = candidate;
-    } else {
-      filePath = resolve2(cwd, nameOrPath);
+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").action(async (templateId, options) => {
+  const manager = getTemplateManager();
+  if (options?.all) {
+    const spinner2 = ora("Fetching template list...").start();
+    try {
+      const templates2 = await manager.listRemoteTemplates();
+      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;
     }
-  }
-  if (!statExists(filePath)) {
-    console.error(`Webhook file not found: ${filePath}`);
-    process.exitCode = 1;
     return;
   }
-  let def;
+  if (!templateId) {
+    const spinner2 = ora("Fetching templates...").start();
+    try {
+      const templates2 = await manager.listRemoteTemplates();
+      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;
+      }
+      templateId = response.templateId;
+    } catch (error) {
+      spinner2.fail("Failed to fetch templates");
+      console.error(chalk.red(error.message));
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const spinner = ora(`Downloading ${templateId}...`).start();
   try {
-    def = loadWebhookFile(filePath);
-  } catch (err) {
-    console.error(err.message);
+    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;
+  }
+});
+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()
+    );
+  }
+  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"
+      )
+    );
     return;
   }
-  if (options.url) def = { ...def, url: options.url };
-  if (options.method)
-    def = { ...def, method: options.method.toUpperCase() };
+  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);
+  }
+  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();
+  }
+  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 {
-    const result = await executeWebhook(def);
-    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);
+    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();
     }
-  } catch (err) {
-    console.error("Request failed:", err.message);
+    console.log(chalk.gray(`  Found: ${totalCount} templates
+`));
+  } catch (error) {
+    spinner.fail("Search failed");
+    console.error(chalk.red(error.message));
     process.exitCode = 1;
   }
 });
-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;
+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;
+  }
+  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;
     }
-    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;
+  }
+  const deleted = manager.deleteAllLocalTemplates();
+  console.log(chalk.green(`
+\u2713 Removed ${deleted} template(s)`));
+  console.log(chalk.gray(`  Storage: ${manager.getTemplatesDir()}
+`));
+});
+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)];
     }
-    for (const templateName of toDownload) {
-      const rel = TEMPLATES[templateName];
-      if (!rel) {
-        console.error(
-          `Unknown template '${templateName}'. Run without arguments to list available templates.`
-        );
-        continue;
+  }
+  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;
+    }
+  }
+  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;
       }
-      const rawUrl = `${TEMPLATE_REPO_BASE}/${rel}`;
+    }
+    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);
+      }
+    }
+  }
+  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",
+    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;
         }
-        writeFileSync(destPath, JSON.stringify(json, null, 2));
-        console.log(`Downloaded ${templateName} -> .webhooks/${fileName}`);
-      } catch (e) {
-        console.error(`Error downloading ${templateName}: ${e.message}`);
+        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}`));
+        }
+      }
+      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
+} 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;
+  clients = /* @__PURE__ */ new Set();
+  captureCount = 0;
   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");
-            }
+    this.capturesDir = capturesDir || join2(homedir2(), ".better-webhook", "captures");
+    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));
+      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`);
+        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 = {};
@@ -383,291 +1295,654 @@ 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.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-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();
+      const fs = __require("fs");
+      fs.unlinkSync(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 unlinkSync2 } 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;
   }
   /**
-   * Load a specific captured webhook by filename or ID
+   * Get a specific capture by ID or partial filename
    */
-  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}`);
+  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 (files.length > 1) {
-        throw new Error(
-          `Multiple captures found with ID ${filePathOrId}: ${files.join(", ")}`
+    }
+    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);
+        }
       }
-      filepath = join4(this.capturesDir, files[0] ?? "");
-    }
-    try {
-      const content = readFileSync2(filepath, "utf8");
-      return JSON.parse(content);
-    } catch (error) {
-      throw new Error(
-        `Failed to load capture from ${filepath}: ${error.message}`
-      );
     }
+    const body = capture2.rawBody || capture2.body;
+    return executeWebhook({
+      url: options.targetUrl,
+      method: options.method || capture2.method,
+      headers,
+      body
+    });
   }
   /**
-   * Replay a captured webhook to a target URL
+   * Convert a capture to a template
    */
-  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
+  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}`
     };
-    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}`);
+  }
+  /**
+   * Get a summary of a capture
+   */
+  getCaptureSummary(captureId) {
+    const captureFile = this.getCapture(captureId);
+    if (!captureFile) {
+      return "Capture not found";
     }
+    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");
   }
   /**
-   * Convert captured webhook to template format
+   * Search captures
    */
-  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
-    };
+  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 headers to template format
+   * Get captures by provider
    */
-  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 });
-      }
+  getCapturesByProvider(provider) {
+    const captures2 = this.listCaptures(1e3);
+    return captures2.filter((c) => c.capture.provider === provider);
+  }
+  /**
+   * Delete a specific capture by ID
+   * @returns true if deleted, false if not found
+   */
+  deleteCapture(captureId) {
+    const captureFile = this.getCapture(captureId);
+    if (!captureFile) {
+      return false;
+    }
+    try {
+      unlinkSync2(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 {
+        unlinkSync2(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";
-var replay = new Command3().name("replay").argument("<captureId>", "ID of the captured webhook to replay").argument("<targetUrl>", "Target URL to replay the webhook to").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(":");
@@ -679,37 +1954,132 @@ var replay = new Command3().name("replay").argument("<captureId>", "ID of the ca
     ]);
   },
   []
-).action(
+).option("-v, --verbose", "Show detailed request/response information").action(
   async (captureId, targetUrl, options) => {
-    const cwd = process.cwd();
-    const capturesDir = findCapturesDir(cwd);
-    const replayer = new WebhookReplayer(capturesDir);
+    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 provider = c.capture.provider ? `[${c.capture.provider}]` : "";
+        return {
+          title: `${c.capture.id.slice(0, 8)} ${provider} ${c.capture.method} ${c.capture.path}`,
+          description: date,
+          value: c.capture.id
+        };
+      });
+      const response = await prompts4({
+        type: "select",
+        name: "captureId",
+        message: "Select a capture to replay:",
+        choices
+      });
+      if (!response.captureId) {
+        console.log(chalk5.yellow("Cancelled"));
+        return;
+      }
+      captureId = response.captureId;
+    }
+    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: "url",
+        message: "Enter target URL:",
+        initial: `http://localhost:3000${captureFile.capture.path}`,
+        validate: (value) => {
+          try {
+            new URL(value);
+            return true;
+          } catch {
+            return "Please enter a valid URL";
+          }
+        }
+      });
+      if (!response.url) {
+        console.log(chalk5.yellow("Cancelled"));
+        return;
+      }
+      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(captureId, targetUrl, {
-        method: options.method,
-        headers: options.header
+      const result = await engine.replay(captureId, {
+        targetUrl,
+        method: options?.method,
+        headers: options?.header
       });
-      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}`);
+      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(`   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/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 Command6().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);
 program.parseAsync(process.argv);