@better-webhook/cli 3.0.0 → 3.1.0

package/dist/index.cjs

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var import_commander6 = require("commander");
+var import_commander7 = require("commander");
 
 // src/commands/templates.ts
 var import_commander = require("commander");
@@ -58,6 +58,7 @@ var WebhookProviderSchema = import_zod.z.enum([
   "github",
   "shopify",
   "twilio",
+  "ragie",
   "sendgrid",
   "slack",
   "discord",
@@ -192,8 +193,8 @@ var TemplateManager = class {
   /**
    * List all remote templates
    */
-  async listRemoteTemplates() {
-    const index = await this.fetchRemoteIndex();
+  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,
@@ -391,7 +392,9 @@ var listCommand = new import_commander.Command().name("list").alias("ls").descri
   const spinner = (0, import_ora.default)("Fetching remote templates...").start();
   try {
     const manager = getTemplateManager();
-    const templates2 = await manager.listRemoteTemplates();
+    const templates2 = await manager.listRemoteTemplates({
+      forceRefresh: !!options.refresh
+    });
     spinner.stop();
     if (templates2.length === 0) {
       console.log(import_chalk.default.yellow("\u{1F4ED} No remote templates found."));
@@ -442,88 +445,98 @@ var listCommand = new import_commander.Command().name("list").alias("ls").descri
     process.exitCode = 1;
   }
 });
-var downloadCommand = new import_commander.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 = (0, import_ora.default)("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(import_chalk.default.green("\u2713 All templates already downloaded"));
-        return;
-      }
-      console.log(
-        import_chalk.default.bold(`
+var downloadCommand = new import_commander.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 = (0, import_ora.default)("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(import_chalk.default.green("\u2713 All templates already downloaded"));
+          return;
+        }
+        console.log(
+          import_chalk.default.bold(`
 Downloading ${toDownload.length} templates...
 `)
-      );
-      for (const t of toDownload) {
-        const downloadSpinner = (0, import_ora.default)(
-          `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}`);
+        );
+        for (const t of toDownload) {
+          const downloadSpinner = (0, import_ora.default)(
+            `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(import_chalk.default.green("\n\u2713 Download complete\n"));
+      } catch (error) {
+        spinner2.fail("Failed to fetch templates");
+        console.error(import_chalk.default.red(error.message));
+        process.exitCode = 1;
       }
-      console.log(import_chalk.default.green("\n\u2713 Download complete\n"));
-    } catch (error) {
-      spinner2.fail("Failed to fetch templates");
-      console.error(import_chalk.default.red(error.message));
-      process.exitCode = 1;
+      return;
     }
-    return;
-  }
-  if (!templateId) {
-    const spinner2 = (0, import_ora.default)("Fetching templates...").start();
-    try {
-      const templates2 = await manager.listRemoteTemplates();
-      spinner2.stop();
-      const notDownloaded = templates2.filter((t) => !t.isDownloaded);
-      if (notDownloaded.length === 0) {
-        console.log(import_chalk.default.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 (0, import_prompts.default)({
-        type: "select",
-        name: "templateId",
-        message: "Select a template to download:",
-        choices
-      });
-      if (!response.templateId) {
-        console.log(import_chalk.default.yellow("Cancelled"));
+    if (!templateId) {
+      const spinner2 = (0, import_ora.default)("Fetching templates...").start();
+      try {
+        const templates2 = await manager.listRemoteTemplates({
+          forceRefresh: !!options?.refresh
+        });
+        spinner2.stop();
+        const notDownloaded = templates2.filter((t) => !t.isDownloaded);
+        if (notDownloaded.length === 0) {
+          console.log(import_chalk.default.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 (0, import_prompts.default)({
+          type: "select",
+          name: "templateId",
+          message: "Select a template to download:",
+          choices
+        });
+        if (!response.templateId) {
+          console.log(import_chalk.default.yellow("Cancelled"));
+          return;
+        }
+        templateId = response.templateId;
+      } catch (error) {
+        spinner2.fail("Failed to fetch templates");
+        console.error(import_chalk.default.red(error.message));
+        process.exitCode = 1;
         return;
       }
-      templateId = response.templateId;
+    }
+    const spinner = (0, import_ora.default)(`Downloading ${templateId}...`).start();
+    try {
+      const template = await manager.downloadTemplate(templateId);
+      spinner.succeed(`Downloaded ${templateId}`);
+      console.log(import_chalk.default.gray(`  Saved to: ${template.filePath}`));
+      console.log(
+        import_chalk.default.gray(`  Run with: better-webhook run ${templateId}
+`)
+      );
     } catch (error) {
-      spinner2.fail("Failed to fetch templates");
+      spinner.fail(`Failed to download ${templateId}`);
       console.error(import_chalk.default.red(error.message));
       process.exitCode = 1;
-      return;
     }
   }
-  const spinner = (0, import_ora.default)(`Downloading ${templateId}...`).start();
-  try {
-    const template = await manager.downloadTemplate(templateId);
-    spinner.succeed(`Downloaded ${templateId}`);
-    console.log(import_chalk.default.gray(`  Saved to: ${template.filePath}`));
-    console.log(import_chalk.default.gray(`  Run with: better-webhook run ${templateId}
-`));
-  } catch (error) {
-    spinner.fail(`Failed to download ${templateId}`);
-    console.error(import_chalk.default.red(error.message));
-    process.exitCode = 1;
-  }
-});
+);
 var localCommand = new import_commander.Command().name("local").description("List downloaded local templates").option("-p, --provider <provider>", "Filter by provider").action((options) => {
   const manager = getTemplateManager();
   let templates2 = manager.listLocalTemplates();
@@ -993,6 +1006,7 @@ function getSecretEnvVarName(provider) {
     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",
@@ -1187,8 +1201,13 @@ var CaptureServer = class {
   capturesDir;
   clients = /* @__PURE__ */ new Set();
   captureCount = 0;
-  constructor(capturesDir) {
+  enableWebSocket;
+  onCapture;
+  constructor(options) {
+    const capturesDir = typeof options === "string" ? options : options?.capturesDir;
     this.capturesDir = capturesDir || (0, import_path2.join)((0, import_os2.homedir)(), ".better-webhook", "captures");
+    this.enableWebSocket = typeof options === "object" ? options?.enableWebSocket !== false : true;
+    this.onCapture = typeof options === "object" ? options?.onCapture : void 0;
     if (!(0, import_fs2.existsSync)(this.capturesDir)) {
       (0, import_fs2.mkdirSync)(this.capturesDir, { recursive: true });
     }
@@ -1205,26 +1224,28 @@ var CaptureServer = class {
   async start(port = 3001, host = "0.0.0.0") {
     return new Promise((resolve, reject) => {
       this.server = (0, import_http.createServer)((req, res) => this.handleRequest(req, res));
-      this.wss = new import_ws.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
-          }
+      if (this.enableWebSocket) {
+        this.wss = new import_ws.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`));
@@ -1242,7 +1263,9 @@ var CaptureServer = class {
         );
         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`);
+        if (this.enableWebSocket) {
+          console.log(`   \u{1F310} WebSocket available for real-time updates`);
+        }
         console.log(`   \u23F9\uFE0F  Press Ctrl+C to stop
 `);
         resolve(actualPort);
@@ -1342,13 +1365,16 @@ var CaptureServer = class {
       console.log(
         `\u{1F4E6} ${req.method} ${urlParts.pathname}${providerStr} -> ${filename}`
       );
-      this.broadcast({
-        type: "capture",
-        payload: {
-          file: filename,
-          capture: captured
-        }
-      });
+      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);
     }
@@ -1375,6 +1401,9 @@ var CaptureServer = class {
     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";
     }
@@ -1454,8 +1483,7 @@ var CaptureServer = class {
       return false;
     }
     try {
-      const fs = require("fs");
-      fs.unlinkSync((0, import_path2.join)(this.capturesDir, capture2.file));
+      (0, import_fs2.unlinkSync)((0, import_path2.join)(this.capturesDir, capture2.file));
       return true;
     } catch {
       return false;
@@ -2078,9 +2106,483 @@ var replay = new import_commander5.Command().name("replay").argument("[captureId
   }
 );
 
+// src/commands/dashboard.ts
+var import_commander6 = require("commander");
+var import_chalk6 = __toESM(require("chalk"), 1);
+
+// src/core/dashboard-server.ts
+var import_express2 = __toESM(require("express"), 1);
+var import_http2 = require("http");
+var import_ws2 = require("ws");
+var import_path4 = __toESM(require("path"), 1);
+var import_fs4 = require("fs");
+var import_url = require("url");
+
+// src/core/dashboard-api.ts
+var import_express = __toESM(require("express"), 1);
+var import_zod2 = require("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 = import_zod2.z.object({
+  captureId: import_zod2.z.string().min(1),
+  targetUrl: import_zod2.z.string().min(1),
+  method: HttpMethodSchema.optional(),
+  headers: import_zod2.z.array(HeaderEntrySchema).optional()
+});
+var TemplateDownloadBodySchema = import_zod2.z.object({
+  id: import_zod2.z.string().min(1)
+});
+var RunTemplateBodySchema = import_zod2.z.object({
+  templateId: import_zod2.z.string().min(1),
+  url: import_zod2.z.string().min(1),
+  secret: import_zod2.z.string().optional(),
+  headers: import_zod2.z.array(HeaderEntrySchema).optional()
+});
+function createDashboardApiRouter(options = {}) {
+  const router = import_express.default.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", import_express.default.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",
+    import_express.default.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",
+    import_express.default.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", import_express.default.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
+var import_meta = {};
+function resolveDashboardDistDir(runtimeDir) {
+  const candidates = [
+    import_path4.default.resolve(runtimeDir, "..", "dashboard"),
+    import_path4.default.resolve(runtimeDir, "..", "..", "dist", "dashboard"),
+    import_path4.default.resolve(runtimeDir, "..", "..", "..", "dashboard", "dist")
+  ];
+  for (const distDir of candidates) {
+    const indexHtml = import_path4.default.join(distDir, "index.html");
+    if ((0, import_fs4.existsSync)(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 = (0, import_express2.default)();
+  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
+    ) : import_path4.default.dirname((0, import_url.fileURLToPath)(import_meta.url))
+  );
+  const { distDir: dashboardDistDir, indexHtml: dashboardIndexHtml } = resolveDashboardDistDir(runtimeDir);
+  app.use(import_express2.default.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 = (0, import_http2.createServer)(app);
+  const wss = new import_ws2.WebSocketServer({ 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 import_commander6.Command().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(import_chalk6.default.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(import_chalk6.default.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(import_chalk6.default.bold("\n\u{1F9ED} Dashboard Server\n"));
+    console.log(import_chalk6.default.gray(`   Dashboard: ${url}/`));
+    console.log(import_chalk6.default.gray(`   Health: ${url}/health`));
+    console.log(import_chalk6.default.gray(`   API Base: ${url}/api`));
+    console.log(import_chalk6.default.gray(`   WebSocket: ${url.replace("http://", "ws://")}/ws`));
+    if (capture2) {
+      console.log();
+      console.log(import_chalk6.default.bold("\u{1F3A3} Capture Server"));
+      console.log(import_chalk6.default.gray(`   Capture: ${capture2.url}`));
+      console.log(import_chalk6.default.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(import_chalk6.default.red(`Failed to start dashboard server: ${error?.message || error}`));
+    process.exitCode = 1;
+  }
+});
+
 // src/index.ts
-var program = new import_commander6.Command().name("better-webhook").description(
+var program = new import_commander7.Command().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.addCommand(templates).addCommand(run).addCommand(capture).addCommand(captures).addCommand(replay).addCommand(dashboard);
 program.parseAsync(process.argv);