hookdash 0.1.0

package/dist/index.js

@@ -0,0 +1,1569 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/db/schema.ts
+var SCHEMA_SQL, CURRENT_SCHEMA_VERSION;
+var init_schema = __esm({
+  "src/db/schema.ts"() {
+    "use strict";
+    SCHEMA_SQL = `
+-- Webhook sources / providers
+CREATE TABLE IF NOT EXISTS sources (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL UNIQUE,
+  provider TEXT NOT NULL DEFAULT 'generic',
+  signing_secret TEXT,
+  active INTEGER DEFAULT 1,
+  created_at TEXT DEFAULT (datetime('now'))
+);
+
+-- Forwarding endpoints
+CREATE TABLE IF NOT EXISTS endpoints (
+  id TEXT PRIMARY KEY,
+  url TEXT NOT NULL,
+  source_id TEXT REFERENCES sources(id) ON DELETE SET NULL,
+  event_filter TEXT,
+  headers TEXT,
+  timeout_ms INTEGER DEFAULT 30000,
+  max_retries INTEGER DEFAULT 8,
+  active INTEGER DEFAULT 1,
+  circuit_state TEXT DEFAULT 'closed',
+  circuit_failure_count INTEGER DEFAULT 0,
+  circuit_last_failure_at TEXT,
+  created_at TEXT DEFAULT (datetime('now'))
+);
+
+-- Incoming webhook events
+CREATE TABLE IF NOT EXISTS events (
+  id TEXT PRIMARY KEY,
+  source_id TEXT NOT NULL REFERENCES sources(id),
+  event_type TEXT,
+  headers TEXT NOT NULL,
+  body TEXT NOT NULL,
+  content_type TEXT,
+  signature_valid INTEGER,
+  received_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_events_received ON events(received_at);
+CREATE INDEX IF NOT EXISTS idx_events_source ON events(source_id);
+CREATE INDEX IF NOT EXISTS idx_events_type ON events(event_type);
+
+-- Delivery attempts
+CREATE TABLE IF NOT EXISTS deliveries (
+  id TEXT PRIMARY KEY,
+  event_id TEXT NOT NULL REFERENCES events(id) ON DELETE CASCADE,
+  endpoint_id TEXT NOT NULL REFERENCES endpoints(id) ON DELETE CASCADE,
+  status TEXT NOT NULL DEFAULT 'pending',
+  attempts INTEGER DEFAULT 0,
+  next_retry_at TEXT,
+  last_status_code INTEGER,
+  last_response_body TEXT,
+  last_error TEXT,
+  created_at TEXT DEFAULT (datetime('now')),
+  completed_at TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_deliveries_status ON deliveries(status);
+CREATE INDEX IF NOT EXISTS idx_deliveries_next_retry ON deliveries(next_retry_at);
+CREATE INDEX IF NOT EXISTS idx_deliveries_event ON deliveries(event_id);
+
+-- Schema version tracking
+CREATE TABLE IF NOT EXISTS schema_version (
+  version INTEGER PRIMARY KEY,
+  applied_at TEXT DEFAULT (datetime('now'))
+);
+`;
+    CURRENT_SCHEMA_VERSION = 1;
+  }
+});
+
+// src/db/connection.ts
+import Database from "better-sqlite3";
+import { resolve as resolve2 } from "path";
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+function getDatabase(config) {
+  if (db) return db;
+  const dbPath = config?.database.path ? resolve2(config.database.path) : resolve2("./hookdash.db");
+  mkdirSync(dirname(dbPath), { recursive: true });
+  db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("synchronous = NORMAL");
+  db.pragma("foreign_keys = ON");
+  db.pragma("busy_timeout = 5000");
+  db.pragma("cache_size = -20000");
+  applySchema(db);
+  console.log(`[hookdash] Database ready at ${dbPath}`);
+  return db;
+}
+function applySchema(database) {
+  database.exec(SCHEMA_SQL);
+  const row = database.prepare(
+    "SELECT version FROM schema_version ORDER BY version DESC LIMIT 1"
+  ).get();
+  const currentVersion = row?.version ?? 0;
+  if (currentVersion < CURRENT_SCHEMA_VERSION) {
+    runMigrations(database, currentVersion, CURRENT_SCHEMA_VERSION);
+    database.prepare(
+      "INSERT OR REPLACE INTO schema_version (version) VALUES (?)"
+    ).run(CURRENT_SCHEMA_VERSION);
+  }
+}
+function runMigrations(database, _fromVersion, _toVersion) {
+}
+function closeDatabase() {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}
+function seedFromConfig(config) {
+  const database = getDatabase(config);
+  const upsertSource = database.prepare(`
+    INSERT INTO sources (id, name, provider, signing_secret, active)
+    VALUES (lower(hex(randomblob(8))), ?, ?, ?, 1)
+    ON CONFLICT(name) DO UPDATE SET
+      provider = excluded.provider,
+      signing_secret = excluded.signing_secret,
+      active = 1
+  `);
+  const getSource = database.prepare("SELECT id FROM sources WHERE name = ?");
+  const upsertEndpoint = database.prepare(`
+    INSERT INTO endpoints (id, url, source_id, event_filter, headers, timeout_ms, max_retries)
+    VALUES (lower(hex(randomblob(8))), ?, ?, ?, ?, ?, ?)
+    ON CONFLICT DO NOTHING
+  `);
+  const checkEndpoint = database.prepare(
+    "SELECT id FROM endpoints WHERE url = ? AND source_id = ?"
+  );
+  const seedTransaction = database.transaction(() => {
+    for (const source of config.sources) {
+      upsertSource.run(source.name, source.provider, source.signing_secret ?? null);
+      const sourceRow = getSource.get(source.name);
+      for (const endpoint of source.endpoints) {
+        const existing = checkEndpoint.get(endpoint.url, sourceRow.id);
+        if (!existing) {
+          upsertEndpoint.run(
+            endpoint.url,
+            sourceRow.id,
+            endpoint.events ? JSON.stringify(endpoint.events) : null,
+            endpoint.headers ? JSON.stringify(endpoint.headers) : null,
+            endpoint.timeout_ms ?? config.delivery.default_timeout,
+            endpoint.max_retries ?? config.delivery.default_max_retries
+          );
+        }
+      }
+    }
+  });
+  seedTransaction();
+  console.log(`[hookdash] Seeded ${config.sources.length} source(s) from config`);
+}
+var db;
+var init_connection = __esm({
+  "src/db/connection.ts"() {
+    "use strict";
+    init_schema();
+    db = null;
+  }
+});
+
+// src/providers/stripe.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var TIMESTAMP_TOLERANCE_SEC, stripeProvider;
+var init_stripe = __esm({
+  "src/providers/stripe.ts"() {
+    "use strict";
+    TIMESTAMP_TOLERANCE_SEC = 300;
+    stripeProvider = {
+      name: "stripe",
+      verify(secret, headers, rawBody) {
+        const sigHeader = headers["stripe-signature"];
+        if (!sigHeader) return false;
+        const parts = /* @__PURE__ */ new Map();
+        for (const pair of sigHeader.split(",")) {
+          const idx = pair.indexOf("=");
+          if (idx === -1) continue;
+          parts.set(pair.slice(0, idx).trim(), pair.slice(idx + 1).trim());
+        }
+        const timestamp = parts.get("t");
+        const signature = parts.get("v1");
+        if (!timestamp || !signature) return false;
+        const ts = parseInt(timestamp, 10);
+        if (Number.isNaN(ts)) return false;
+        const now = Math.floor(Date.now() / 1e3);
+        if (Math.abs(now - ts) > TIMESTAMP_TOLERANCE_SEC) return false;
+        const signedPayload = `${timestamp}.${rawBody.toString("utf8")}`;
+        const expectedSig = createHmac("sha256", secret).update(signedPayload).digest("hex");
+        const sigBuf = Buffer.from(signature, "hex");
+        const expectedBuf = Buffer.from(expectedSig, "hex");
+        if (sigBuf.length !== expectedBuf.length) return false;
+        return timingSafeEqual(sigBuf, expectedBuf);
+      },
+      extractEventType(_headers, body) {
+        if (body && typeof body === "object" && "type" in body) {
+          const t = body.type;
+          return typeof t === "string" ? t : null;
+        }
+        return null;
+      }
+    };
+  }
+});
+
+// src/providers/github.ts
+import { createHmac as createHmac2, timingSafeEqual as timingSafeEqual2 } from "crypto";
+var githubProvider;
+var init_github = __esm({
+  "src/providers/github.ts"() {
+    "use strict";
+    githubProvider = {
+      name: "github",
+      verify(secret, headers, rawBody) {
+        const sigHeader = headers["x-hub-signature-256"];
+        if (!sigHeader) return false;
+        const prefix = "sha256=";
+        if (!sigHeader.startsWith(prefix)) return false;
+        const signature = sigHeader.slice(prefix.length);
+        const expectedSig = createHmac2("sha256", secret).update(rawBody).digest("hex");
+        const sigBuf = Buffer.from(signature, "hex");
+        const expectedBuf = Buffer.from(expectedSig, "hex");
+        if (sigBuf.length !== expectedBuf.length) return false;
+        return timingSafeEqual2(sigBuf, expectedBuf);
+      },
+      extractEventType(headers, _body) {
+        return headers["x-github-event"] ?? null;
+      }
+    };
+  }
+});
+
+// src/providers/twilio.ts
+import { createHmac as createHmac3, timingSafeEqual as timingSafeEqual3 } from "crypto";
+var twilioProvider;
+var init_twilio = __esm({
+  "src/providers/twilio.ts"() {
+    "use strict";
+    twilioProvider = {
+      name: "twilio",
+      verify(secret, headers, rawBody) {
+        const sigHeader = headers["x-twilio-signature"];
+        if (!sigHeader) return false;
+        const expectedSig = createHmac3("sha1", secret).update(rawBody).digest("base64");
+        const sigBuf = Buffer.from(sigHeader, "base64");
+        const expectedBuf = Buffer.from(expectedSig, "base64");
+        if (sigBuf.length !== expectedBuf.length) return false;
+        return timingSafeEqual3(sigBuf, expectedBuf);
+      },
+      extractEventType(_headers, body) {
+        if (body && typeof body === "object") {
+          const b = body;
+          if (typeof b.EventType === "string") return b.EventType;
+          if (typeof b.event_type === "string") return b.event_type;
+          if (typeof b.type === "string") return b.type;
+        }
+        return null;
+      }
+    };
+  }
+});
+
+// src/providers/shopify.ts
+import { createHmac as createHmac4, timingSafeEqual as timingSafeEqual4 } from "crypto";
+var shopifyProvider;
+var init_shopify = __esm({
+  "src/providers/shopify.ts"() {
+    "use strict";
+    shopifyProvider = {
+      name: "shopify",
+      verify(secret, headers, rawBody) {
+        const sigHeader = headers["x-shopify-hmac-sha256"];
+        if (!sigHeader) return false;
+        const expectedSig = createHmac4("sha256", secret).update(rawBody).digest("base64");
+        const sigBuf = Buffer.from(sigHeader, "base64");
+        const expectedBuf = Buffer.from(expectedSig, "base64");
+        if (sigBuf.length !== expectedBuf.length) return false;
+        return timingSafeEqual4(sigBuf, expectedBuf);
+      },
+      extractEventType(headers, _body) {
+        return headers["x-shopify-topic"] ?? null;
+      }
+    };
+  }
+});
+
+// src/providers/generic.ts
+import { createHmac as createHmac5, timingSafeEqual as timingSafeEqual5 } from "crypto";
+var genericProvider;
+var init_generic = __esm({
+  "src/providers/generic.ts"() {
+    "use strict";
+    genericProvider = {
+      name: "generic",
+      verify(secret, headers, rawBody) {
+        const sigHeader = headers["x-webhook-signature"] ?? headers["x-signature"];
+        if (!sigHeader) return false;
+        const expectedSig = createHmac5("sha256", secret).update(rawBody).digest("hex");
+        const sigBuf = Buffer.from(sigHeader, "hex");
+        const expectedBuf = Buffer.from(expectedSig, "hex");
+        if (sigBuf.length !== expectedBuf.length) return false;
+        return timingSafeEqual5(sigBuf, expectedBuf);
+      },
+      extractEventType(_headers, body) {
+        if (body && typeof body === "object") {
+          const b = body;
+          if (typeof b.event === "string") return b.event;
+          if (typeof b.type === "string") return b.type;
+        }
+        return null;
+      }
+    };
+  }
+});
+
+// src/providers/registry.ts
+function register(provider) {
+  providers.set(provider.name, provider);
+}
+function getProvider(name) {
+  const provider = providers.get(name);
+  if (!provider) {
+    const available = [...providers.keys()].join(", ");
+    throw new Error(
+      `Unknown webhook provider "${name}". Available providers: ${available}`
+    );
+  }
+  return provider;
+}
+var providers;
+var init_registry = __esm({
+  "src/providers/registry.ts"() {
+    "use strict";
+    init_stripe();
+    init_github();
+    init_twilio();
+    init_shopify();
+    init_generic();
+    providers = /* @__PURE__ */ new Map();
+    register(stripeProvider);
+    register(githubProvider);
+    register(twilioProvider);
+    register(shopifyProvider);
+    register(genericProvider);
+  }
+});
+
+// src/ingestion/parser.ts
+function normalizeHeaders(headers) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (value === void 0) continue;
+    normalized[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+  }
+  return normalized;
+}
+function parseBodyEventType(rawBody) {
+  let parsed = null;
+  let eventType = null;
+  try {
+    parsed = JSON.parse(rawBody.toString("utf8"));
+  } catch {
+    return { parsed: null, eventType: null };
+  }
+  if (parsed && typeof parsed === "object") {
+    const obj = parsed;
+    for (const field of ["event", "type", "event_type", "eventType", "action"]) {
+      if (typeof obj[field] === "string") {
+        eventType = obj[field];
+        break;
+      }
+    }
+  }
+  return { parsed, eventType };
+}
+function matchesEventFilter(eventType, filterPatterns) {
+  if (!filterPatterns || filterPatterns.length === 0) return true;
+  if (!eventType) return false;
+  return filterPatterns.some((pattern) => globMatch(pattern, eventType));
+}
+function globMatch(pattern, value) {
+  if (pattern === "*" || pattern === "**") return true;
+  let regexStr = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const char = pattern[i];
+    if (char === "*") {
+      if (pattern[i + 1] === "*") {
+        regexStr += ".*";
+        i += 2;
+      } else {
+        regexStr += "[^.]*";
+        i += 1;
+      }
+    } else if (char === "?") {
+      regexStr += "[^.]";
+      i += 1;
+    } else if (".+^${}()|[]\\".includes(char)) {
+      regexStr += `\\${char}`;
+      i += 1;
+    } else {
+      regexStr += char;
+      i += 1;
+    }
+  }
+  const regex = new RegExp(`^${regexStr}$`);
+  return regex.test(value);
+}
+var init_parser = __esm({
+  "src/ingestion/parser.ts"() {
+    "use strict";
+  }
+});
+
+// src/delivery/circuit-breaker.ts
+var CircuitBreaker;
+var init_circuit_breaker = __esm({
+  "src/delivery/circuit-breaker.ts"() {
+    "use strict";
+    CircuitBreaker = class {
+      db;
+      failureThreshold = 5;
+      cooldownMs = 6e4;
+      // 60 seconds
+      constructor(db2) {
+        this.db = db2;
+      }
+      /**
+       * Check if we can deliver to this endpoint.
+       * If state is open, checks if cooldown has expired to transition to half-open.
+       */
+      canDeliver(endpointId) {
+        const row = this.db.prepare(
+          "SELECT circuit_state, circuit_last_failure_at FROM endpoints WHERE id = ?"
+        ).get(endpointId);
+        if (!row) return false;
+        if (row.circuit_state === "closed" || row.circuit_state === "half-open") {
+          return true;
+        }
+        if (row.circuit_state === "open" && row.circuit_last_failure_at) {
+          const lastFailure = new Date(row.circuit_last_failure_at).getTime();
+          const elapsed = Date.now() - lastFailure;
+          if (elapsed >= this.cooldownMs) {
+            this.db.prepare(
+              "UPDATE endpoints SET circuit_state = 'half-open' WHERE id = ?"
+            ).run(endpointId);
+            return true;
+          }
+        }
+        return false;
+      }
+      /**
+       * Reset circuit to closed on successful delivery.
+       */
+      recordSuccess(endpointId) {
+        this.db.prepare(`
+      UPDATE endpoints
+      SET circuit_state = 'closed',
+          circuit_failure_count = 0,
+          circuit_last_failure_at = NULL
+      WHERE id = ?
+    `).run(endpointId);
+      }
+      /**
+       * Record failure. If consecutive failures exceed threshold, open the circuit.
+       */
+      recordFailure(endpointId) {
+        const row = this.db.prepare(
+          "SELECT circuit_failure_count, circuit_state FROM endpoints WHERE id = ?"
+        ).get(endpointId);
+        if (!row) return;
+        const newFailureCount = row.circuit_failure_count + 1;
+        const nowStr = (/* @__PURE__ */ new Date()).toISOString();
+        if (newFailureCount >= this.failureThreshold || row.circuit_state === "half-open") {
+          this.db.prepare(`
+        UPDATE endpoints
+        SET circuit_state = 'open',
+            circuit_failure_count = ?,
+            circuit_last_failure_at = ?
+        WHERE id = ?
+      `).run(newFailureCount, nowStr, endpointId);
+        } else {
+          this.db.prepare(`
+        UPDATE endpoints
+        SET circuit_failure_count = ?,
+            circuit_last_failure_at = ?
+        WHERE id = ?
+      `).run(newFailureCount, nowStr, endpointId);
+        }
+      }
+    };
+  }
+});
+
+// src/delivery/retry.ts
+function getNextRetryDelay(attempt) {
+  const BASE_DELAY = 1e3;
+  const MAX_DELAY = 36e5;
+  const JITTER_FACTOR = 0.25;
+  const exponential = BASE_DELAY * Math.pow(2, attempt);
+  const capped = Math.min(exponential, MAX_DELAY);
+  const jitter = capped * JITTER_FACTOR * Math.random();
+  return capped + jitter;
+}
+function shouldRetry(statusCode) {
+  if (statusCode === 0 || statusCode === -1) return true;
+  if (statusCode === 429) return true;
+  if (statusCode >= 500 && statusCode < 600) return true;
+  return false;
+}
+var init_retry = __esm({
+  "src/delivery/retry.ts"() {
+    "use strict";
+  }
+});
+
+// src/delivery/worker.ts
+import { EventEmitter } from "events";
+var deliveryEvents, DeliveryWorker;
+var init_worker = __esm({
+  "src/delivery/worker.ts"() {
+    "use strict";
+    init_connection();
+    init_circuit_breaker();
+    init_retry();
+    deliveryEvents = new EventEmitter();
+    DeliveryWorker = class {
+      db;
+      intervalId = null;
+      pollInterval;
+      defaultTimeout;
+      circuitBreaker;
+      isProcessing = false;
+      constructor(config) {
+        this.db = getDatabase(config);
+        this.pollInterval = config.delivery.poll_interval;
+        this.defaultTimeout = config.delivery.default_timeout;
+        this.circuitBreaker = new CircuitBreaker(this.db);
+      }
+      start() {
+        if (this.intervalId) return;
+        this.intervalId = setInterval(async () => {
+          if (this.isProcessing) return;
+          this.isProcessing = true;
+          try {
+            await this.processQueue();
+          } catch (err) {
+            console.error("[hookdash-worker] Error processing queue:", err);
+          } finally {
+            this.isProcessing = false;
+          }
+        }, this.pollInterval);
+        console.log(`[hookdash-worker] Started queue worker (poll: ${this.pollInterval}ms)`);
+      }
+      stop() {
+        if (this.intervalId) {
+          clearInterval(this.intervalId);
+          this.intervalId = null;
+          console.log("[hookdash-worker] Stopped queue worker");
+        }
+      }
+      async processQueue() {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const dueDeliveries = this.db.prepare(`
+      SELECT d.*, e.url as endpoint_url, e.headers as endpoint_headers, e.timeout_ms as endpoint_timeout,
+             e.max_retries as endpoint_max_retries, ev.body as event_body, ev.headers as event_headers,
+             ev.content_type as event_content_type
+      FROM deliveries d
+      JOIN endpoints e ON d.endpoint_id = e.id
+      JOIN events ev ON d.event_id = ev.id
+      WHERE (d.status = 'pending' OR (d.status = 'retrying' AND d.next_retry_at <= ?))
+      LIMIT 10
+    `).all(now);
+        if (dueDeliveries.length === 0) return;
+        for (const d of dueDeliveries) {
+          if (!this.circuitBreaker.canDeliver(d.endpoint_id)) {
+            continue;
+          }
+          await this.deliver(d);
+        }
+      }
+      async deliver(d) {
+        const endpointHeaders = d.endpoint_headers ? JSON.parse(d.endpoint_headers) : {};
+        const eventHeaders = d.event_headers ? JSON.parse(d.event_headers) : {};
+        const headers = {
+          "content-type": d.event_content_type || "application/json",
+          ...eventHeaders,
+          ...endpointHeaders,
+          "x-hookdash-delivery-id": d.id,
+          "x-hookdash-event-id": d.event_id,
+          "x-hookdash-attempt": (d.attempts + 1).toString()
+        };
+        delete headers["connection"];
+        delete headers["host"];
+        delete headers["content-length"];
+        const timeout = d.endpoint_timeout || this.defaultTimeout;
+        const controller = new AbortController();
+        const id = setTimeout(() => controller.abort(), timeout);
+        const startTime = Date.now();
+        let status = "failed";
+        let statusCode = null;
+        let responseBody = "";
+        let errorMsg = null;
+        try {
+          const response = await fetch(d.endpoint_url, {
+            method: "POST",
+            headers,
+            body: d.event_body,
+            signal: controller.signal
+          });
+          statusCode = response.status;
+          responseBody = await response.text();
+          if (response.ok) {
+            status = "success";
+            this.circuitBreaker.recordSuccess(d.endpoint_id);
+          } else {
+            status = "failed";
+            this.circuitBreaker.recordFailure(d.endpoint_id);
+          }
+        } catch (err) {
+          this.circuitBreaker.recordFailure(d.endpoint_id);
+          if (err.name === "AbortError") {
+            errorMsg = `Timeout after ${timeout}ms`;
+          } else {
+            errorMsg = err.message || "Network error";
+          }
+        } finally {
+          clearTimeout(id);
+        }
+        const attempts = d.attempts + 1;
+        const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        let nextRetryAt = null;
+        if (status === "failed") {
+          const maxRetries = d.endpoint_max_retries ?? 8;
+          const shouldRetryRequest = shouldRetry(statusCode ?? -1);
+          if (attempts < maxRetries && shouldRetryRequest) {
+            status = "retrying";
+            const delay = getNextRetryDelay(attempts);
+            nextRetryAt = new Date(Date.now() + delay).toISOString();
+          } else {
+            status = "dead";
+          }
+        }
+        this.db.prepare(`
+      UPDATE deliveries
+      SET status = ?,
+          attempts = ?,
+          next_retry_at = ?,
+          last_status_code = ?,
+          last_response_body = ?,
+          last_error = ?,
+          completed_at = ?
+      WHERE id = ?
+    `).run(
+          status,
+          attempts,
+          nextRetryAt,
+          statusCode,
+          responseBody.substring(0, 1e4),
+          // Cap payload response length
+          errorMsg,
+          completedAt,
+          d.id
+        );
+        deliveryEvents.emit("delivery:update", {
+          id: d.id,
+          event_id: d.event_id,
+          endpoint_id: d.endpoint_id,
+          endpoint_url: d.endpoint_url,
+          status,
+          attempts,
+          next_retry_at: nextRetryAt,
+          last_status_code: statusCode,
+          last_error: errorMsg,
+          completed_at: completedAt
+        });
+      }
+    };
+  }
+});
+
+// src/api/sse.ts
+function broadcastSSE(event, data) {
+  for (const send of activeClients) {
+    send(event, data);
+  }
+}
+var activeClients, sseRoutes;
+var init_sse = __esm({
+  "src/api/sse.ts"() {
+    "use strict";
+    init_worker();
+    activeClients = /* @__PURE__ */ new Set();
+    sseRoutes = async (fastify) => {
+      fastify.get("/stream", async (request, reply) => {
+        reply.raw.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive",
+          "Access-Control-Allow-Origin": "*"
+        });
+        const send = (event, data) => {
+          reply.raw.write(`event: ${event}
+`);
+          reply.raw.write(`data: ${JSON.stringify(data)}
+
+`);
+        };
+        activeClients.add(send);
+        const heartbeatId = setInterval(() => {
+          reply.raw.write(": heartbeat\n\n");
+        }, 15e3);
+        send("connected", { timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+        const onDeliveryUpdate = (data) => {
+          send("delivery:update", data);
+        };
+        deliveryEvents.on("delivery:update", onDeliveryUpdate);
+        request.raw.on("close", () => {
+          clearInterval(heartbeatId);
+          activeClients.delete(send);
+          deliveryEvents.off("delivery:update", onDeliveryUpdate);
+        });
+        reply.hijack();
+      });
+    };
+  }
+});
+
+// src/ingestion/routes.ts
+var routes_exports = {};
+__export(routes_exports, {
+  default: () => ingestionRoutes
+});
+import { nanoid } from "nanoid";
+async function ingestionRoutes(fastify) {
+  fastify.post(
+    "/webhook/:source",
+    async (request, reply) => {
+      const { source: sourceName } = request.params;
+      const rawBody = request.rawBody;
+      if (!rawBody) {
+        return reply.status(400).send({
+          error: "Missing raw body. Ensure @fastify/raw-body is registered."
+        });
+      }
+      const db2 = getDatabase();
+      const source = db2.prepare("SELECT * FROM sources WHERE name = ? AND active = 1").get(sourceName);
+      if (!source) {
+        return reply.status(404).send({
+          error: `Unknown webhook source "${sourceName}".`
+        });
+      }
+      const headers = normalizeHeaders(
+        request.headers
+      );
+      const { parsed: parsedBody } = parseBodyEventType(rawBody);
+      let signatureValid = null;
+      if (source.signing_secret) {
+        try {
+          const provider = getProvider(source.provider);
+          signatureValid = provider.verify(source.signing_secret, headers, rawBody);
+          if (!signatureValid) {
+            return reply.status(401).send({ error: "Invalid webhook signature." });
+          }
+        } catch (err) {
+          fastify.log.error(err, `Provider verification error for source "${sourceName}"`);
+          return reply.status(500).send({ error: "Signature verification failed." });
+        }
+      }
+      let eventType = null;
+      try {
+        const provider = getProvider(source.provider);
+        eventType = provider.extractEventType(headers, parsedBody ?? rawBody.toString("utf8"));
+      } catch {
+      }
+      const eventId = nanoid();
+      const contentType = headers["content-type"] ?? null;
+      db2.prepare(
+        `INSERT INTO events (id, source_id, event_type, headers, body, content_type, signature_valid)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        eventId,
+        source.id,
+        eventType,
+        JSON.stringify(headers),
+        rawBody.toString("utf8"),
+        contentType,
+        signatureValid === null ? null : signatureValid ? 1 : 0
+      );
+      const endpoints = db2.prepare(
+        "SELECT * FROM endpoints WHERE (source_id = ? OR source_id IS NULL) AND active = 1"
+      ).all(source.id);
+      const deliveryIds = [];
+      const insertDelivery = db2.prepare(
+        `INSERT INTO deliveries (id, event_id, endpoint_id, status)
+         VALUES (?, ?, ?, 'pending')`
+      );
+      const createDeliveries = db2.transaction(() => {
+        for (const endpoint of endpoints) {
+          let filterPatterns = null;
+          if (endpoint.event_filter) {
+            try {
+              filterPatterns = JSON.parse(endpoint.event_filter);
+            } catch {
+            }
+          }
+          if (!matchesEventFilter(eventType, filterPatterns)) {
+            continue;
+          }
+          const deliveryId = nanoid();
+          insertDelivery.run(deliveryId, eventId, endpoint.id);
+          deliveryIds.push(deliveryId);
+        }
+      });
+      createDeliveries();
+      broadcastSSE("event:new", {
+        id: eventId,
+        source_id: source.id,
+        source_name: source.name,
+        source_provider: source.provider,
+        event_type: eventType,
+        delivery_count: deliveryIds.length,
+        received_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return reply.status(202).send({
+        event_id: eventId,
+        event_type: eventType,
+        deliveries: deliveryIds.length
+      });
+    }
+  );
+}
+var init_routes = __esm({
+  "src/ingestion/routes.ts"() {
+    "use strict";
+    init_connection();
+    init_registry();
+    init_parser();
+    init_sse();
+  }
+});
+
+// src/api/events.ts
+import { nanoid as nanoid2 } from "nanoid";
+var eventRoutes;
+var init_events = __esm({
+  "src/api/events.ts"() {
+    "use strict";
+    eventRoutes = async (fastify) => {
+      const { db: db2 } = fastify;
+      fastify.get("/", async (request, reply) => {
+        const query = request.query;
+        const page = Math.max(1, parseInt(query.page) || 1);
+        const perPage = Math.min(100, Math.max(1, parseInt(query.per_page) || 20));
+        const offset = (page - 1) * perPage;
+        const conditions = [];
+        const params = [];
+        if (query.source) {
+          conditions.push("s.name = ?");
+          params.push(query.source);
+        }
+        if (query.event_type) {
+          conditions.push("e.event_type = ?");
+          params.push(query.event_type);
+        }
+        if (query.status) {
+          conditions.push(`EXISTS (
+        SELECT 1 FROM deliveries d
+        WHERE d.event_id = e.id AND d.status = ?
+      )`);
+          params.push(query.status);
+        }
+        if (query.from) {
+          conditions.push("e.received_at >= ?");
+          params.push(query.from);
+        }
+        if (query.to) {
+          conditions.push("e.received_at <= ?");
+          params.push(query.to);
+        }
+        if (query.search) {
+          conditions.push("(e.body LIKE ? OR e.event_type LIKE ? OR e.id LIKE ?)");
+          const wild = `%${query.search}%`;
+          params.push(wild, wild, wild);
+        }
+        const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+        const totalRow = db2.prepare(`
+      SELECT COUNT(DISTINCT e.id) as count
+      FROM events e
+      JOIN sources s ON e.source_id = s.id
+      ${whereClause}
+    `).get(...params);
+        const total = totalRow?.count || 0;
+        const eventsQuery = `
+      SELECT e.id, e.event_type, e.received_at, e.signature_valid,
+             s.name as source_name, s.provider as source_provider,
+             COUNT(d.id) as delivery_count,
+             SUM(CASE WHEN d.status = 'success' THEN 1 ELSE 0 END) as success_count,
+             SUM(CASE WHEN d.status IN ('failed', 'retrying', 'dead') THEN 1 ELSE 0 END) as failed_count
+      FROM events e
+      JOIN sources s ON e.source_id = s.id
+      LEFT JOIN deliveries d ON d.event_id = e.id
+      ${whereClause}
+      GROUP BY e.id
+      ORDER BY e.received_at DESC
+      LIMIT ? OFFSET ?
+    `;
+        const events = db2.prepare(eventsQuery).all(...params, perPage, offset);
+        const response = {
+          data: events,
+          total,
+          page,
+          per_page: perPage,
+          total_pages: Math.ceil(total / perPage)
+        };
+        return response;
+      });
+      fastify.get("/:id", async (request, reply) => {
+        const { id } = request.params;
+        const event = db2.prepare(`
+      SELECT e.*, s.name as source_name, s.provider as source_provider
+      FROM events e
+      JOIN sources s ON e.source_id = s.id
+      WHERE e.id = ?
+    `).get(id);
+        if (!event) {
+          return reply.status(404).send({ error: "Event not found" });
+        }
+        const deliveries = db2.prepare(`
+      SELECT d.*, e.url as endpoint_url
+      FROM deliveries d
+      JOIN endpoints e ON d.endpoint_id = e.id
+      WHERE d.event_id = ?
+      ORDER BY d.created_at ASC
+    `).all(id);
+        return {
+          ...event,
+          deliveries
+        };
+      });
+      fastify.post("/:id/replay", async (request, reply) => {
+        const { id } = request.params;
+        const event = db2.prepare("SELECT id FROM events WHERE id = ?").get(id);
+        if (!event) {
+          return reply.status(404).send({ error: "Event not found" });
+        }
+        const endpoints = db2.prepare(`
+      SELECT ep.id
+      FROM endpoints ep
+      JOIN events ev ON ev.source_id = ep.source_id
+      WHERE ev.id = ? AND ep.active = 1
+    `).all(id);
+        const newDeliveryIds = [];
+        const insertDelivery = db2.prepare(`
+      INSERT INTO deliveries (id, event_id, endpoint_id, status, attempts)
+      VALUES (?, ?, ?, 'pending', 0)
+    `);
+        db2.transaction(() => {
+          for (const ep of endpoints) {
+            const deliveryId = `del_${nanoid2(12)}`;
+            insertDelivery.run(deliveryId, id, ep.id);
+            newDeliveryIds.push(deliveryId);
+          }
+        })();
+        return {
+          success: true,
+          message: `Requeued ${newDeliveryIds.length} deliveries`,
+          delivery_ids: newDeliveryIds
+        };
+      });
+      fastify.delete("/:id", async (request, reply) => {
+        const { id } = request.params;
+        const result = db2.prepare("DELETE FROM events WHERE id = ?").run(id);
+        if (result.changes === 0) {
+          return reply.status(404).send({ error: "Event not found" });
+        }
+        return { success: true };
+      });
+    };
+  }
+});
+
+// src/api/endpoints.ts
+import { nanoid as nanoid3 } from "nanoid";
+var endpointRoutes;
+var init_endpoints = __esm({
+  "src/api/endpoints.ts"() {
+    "use strict";
+    endpointRoutes = async (fastify) => {
+      const { db: db2 } = fastify;
+      fastify.get("/", async (request, reply) => {
+        const endpoints = db2.prepare(`
+      SELECT e.*, s.name as source_name, s.provider as source_provider
+      FROM endpoints e
+      LEFT JOIN sources s ON e.source_id = s.id
+      ORDER BY e.created_at DESC
+    `).all();
+        return endpoints.map((ep) => ({
+          ...ep,
+          event_filter: ep.event_filter ? JSON.parse(ep.event_filter) : null,
+          headers: ep.headers ? JSON.parse(ep.headers) : null
+        }));
+      });
+      fastify.post("/", async (request, reply) => {
+        const body = request.body;
+        if (!body.url) {
+          return reply.status(400).send({ error: "url is required" });
+        }
+        const id = `ep_${nanoid3(12)}`;
+        const eventFilter = body.event_filter ? JSON.stringify(body.event_filter) : null;
+        const customHeaders = body.headers ? JSON.stringify(body.headers) : null;
+        db2.prepare(`
+      INSERT INTO endpoints (
+        id, url, source_id, event_filter, headers, timeout_ms, max_retries, active
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+          id,
+          body.url,
+          body.source_id || null,
+          eventFilter,
+          customHeaders,
+          body.timeout_ms ?? 3e4,
+          body.max_retries ?? 8,
+          body.active !== void 0 ? body.active ? 1 : 0 : 1
+        );
+        const created = db2.prepare("SELECT * FROM endpoints WHERE id = ?").get(id);
+        return {
+          ...created,
+          event_filter: created.event_filter ? JSON.parse(created.event_filter) : null,
+          headers: created.headers ? JSON.parse(created.headers) : null
+        };
+      });
+      fastify.put("/:id", async (request, reply) => {
+        const { id } = request.params;
+        const body = request.body;
+        const existing = db2.prepare("SELECT id FROM endpoints WHERE id = ?").get(id);
+        if (!existing) {
+          return reply.status(404).send({ error: "Endpoint not found" });
+        }
+        const eventFilter = body.event_filter ? JSON.stringify(body.event_filter) : null;
+        const customHeaders = body.headers ? JSON.stringify(body.headers) : null;
+        db2.prepare(`
+      UPDATE endpoints
+      SET url = COALESCE(?, url),
+          source_id = COALESCE(?, source_id),
+          event_filter = ?,
+          headers = ?,
+          timeout_ms = COALESCE(?, timeout_ms),
+          max_retries = COALESCE(?, max_retries),
+          active = COALESCE(?, active)
+      WHERE id = ?
+    `).run(
+          body.url,
+          body.source_id,
+          eventFilter,
+          customHeaders,
+          body.timeout_ms,
+          body.max_retries,
+          body.active !== void 0 ? body.active ? 1 : 0 : null,
+          id
+        );
+        const updated = db2.prepare("SELECT * FROM endpoints WHERE id = ?").get(id);
+        return {
+          ...updated,
+          event_filter: updated.event_filter ? JSON.parse(updated.event_filter) : null,
+          headers: updated.headers ? JSON.parse(updated.headers) : null
+        };
+      });
+      fastify.delete("/:id", async (request, reply) => {
+        const { id } = request.params;
+        const result = db2.prepare("DELETE FROM endpoints WHERE id = ?").run(id);
+        if (result.changes === 0) {
+          return reply.status(404).send({ error: "Endpoint not found" });
+        }
+        return { success: true };
+      });
+      fastify.post("/:id/test", async (request, reply) => {
+        const { id } = request.params;
+        const ep = db2.prepare("SELECT url, headers, timeout_ms FROM endpoints WHERE id = ?").get(id);
+        if (!ep) {
+          return reply.status(404).send({ error: "Endpoint not found" });
+        }
+        const customHeaders = ep.headers ? JSON.parse(ep.headers) : {};
+        const timeout = ep.timeout_ms || 3e4;
+        const testPayload = {
+          event: "hookdash.test",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          test: true,
+          message: "This is a test webhook from hookdash dashboard"
+        };
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeout);
+        try {
+          const response = await fetch(ep.url, {
+            method: "POST",
+            headers: {
+              "content-type": "application/json",
+              "x-hookdash-test": "true",
+              ...customHeaders
+            },
+            body: JSON.stringify(testPayload),
+            signal: controller.signal
+          });
+          const responseText = await response.text();
+          return {
+            success: response.ok,
+            status_code: response.status,
+            response: responseText.substring(0, 1e3)
+          };
+        } catch (err) {
+          return {
+            success: false,
+            error: err.name === "AbortError" ? `Timeout after ${timeout}ms` : err.message
+          };
+        } finally {
+          clearTimeout(timer);
+        }
+      });
+    };
+  }
+});
+
+// src/api/stats.ts
+var statsRoutes;
+var init_stats = __esm({
+  "src/api/stats.ts"() {
+    "use strict";
+    statsRoutes = async (fastify) => {
+      const { db: db2 } = fastify;
+      fastify.get("/", async (request, reply) => {
+        const todayStr = (/* @__PURE__ */ new Date()).toISOString().split("T")[0] + "T00:00:00.000Z";
+        const eventCounts = db2.prepare(`
+      SELECT
+        COUNT(id) as total,
+        SUM(CASE WHEN received_at >= ? THEN 1 ELSE 0 END) as today
+      FROM events
+    `).get(todayStr);
+        const totalEvents = eventCounts?.total || 0;
+        const eventsToday = eventCounts?.today || 0;
+        const deliveryStats = db2.prepare(`
+      SELECT
+        status,
+        COUNT(id) as count
+      FROM deliveries
+      GROUP BY status
+    `).all();
+        let totalDeliveries = 0;
+        let successfulDeliveries = 0;
+        let failedDeliveries = 0;
+        let deadDeliveries = 0;
+        let pendingDeliveries = 0;
+        for (const row of deliveryStats) {
+          totalDeliveries += row.count;
+          if (row.status === "success") {
+            successfulDeliveries = row.count;
+          } else if (row.status === "failed" || row.status === "retrying") {
+            failedDeliveries += row.count;
+            if (row.status === "pending") pendingDeliveries = row.count;
+          } else if (row.status === "dead") {
+            deadDeliveries = row.count;
+          } else if (row.status === "pending") {
+            pendingDeliveries = row.count;
+          }
+        }
+        const successRate = totalDeliveries > 0 ? Math.round(successfulDeliveries / (successfulDeliveries + deadDeliveries + failedDeliveries || 1) * 1e3) / 10 : 100;
+        const activeHours = [];
+        for (let i = 23; i >= 0; i--) {
+          const d = new Date(Date.now() - i * 3600 * 1e3);
+          d.setMinutes(0, 0, 0);
+          const isoStr = d.toISOString();
+          const formatted = isoStr.replace("T", " ").substring(0, 16);
+          activeHours.push({ hour: formatted, count: 0 });
+        }
+        const last24h = new Date(Date.now() - 24 * 3600 * 1e3).toISOString();
+        const dbHours = db2.prepare(`
+      SELECT strftime('%Y-%m-%d %H:00', received_at) as hour_bucket, COUNT(id) as count
+      FROM events
+      WHERE received_at >= ?
+      GROUP BY hour_bucket
+      ORDER BY hour_bucket ASC
+    `).all(last24h);
+        for (const dbHour of dbHours) {
+          const match = activeHours.find((h) => h.hour === dbHour.hour_bucket);
+          if (match) {
+            match.count = dbHour.count;
+          }
+        }
+        const topSources = db2.prepare(`
+      SELECT s.name, COUNT(e.id) as count
+      FROM events e
+      JOIN sources s ON e.source_id = s.id
+      GROUP BY s.name
+      ORDER BY count DESC
+      LIMIT 5
+    `).all();
+        const topEventTypes = db2.prepare(`
+      SELECT event_type as type, COUNT(id) as count
+      FROM events
+      WHERE event_type IS NOT NULL
+      GROUP BY event_type
+      ORDER BY count DESC
+      LIMIT 10
+    `).all();
+        const stats = {
+          total_events: totalEvents,
+          events_today: eventsToday,
+          total_deliveries: totalDeliveries,
+          successful_deliveries: successfulDeliveries,
+          failed_deliveries: failedDeliveries,
+          dead_deliveries: deadDeliveries,
+          pending_deliveries: pendingDeliveries,
+          success_rate: successRate,
+          events_per_hour: activeHours,
+          top_sources: topSources,
+          top_event_types: topEventTypes
+        };
+        return stats;
+      });
+    };
+  }
+});
+
+// src/api/routes.ts
+var routes_exports2 = {};
+__export(routes_exports2, {
+  apiRoutes: () => apiRoutes
+});
+var apiRoutes;
+var init_routes2 = __esm({
+  "src/api/routes.ts"() {
+    "use strict";
+    init_events();
+    init_endpoints();
+    init_stats();
+    init_sse();
+    apiRoutes = async (fastify) => {
+      await fastify.register(eventRoutes, { prefix: "/events" });
+      await fastify.register(endpointRoutes, { prefix: "/endpoints" });
+      await fastify.register(statsRoutes, { prefix: "/stats" });
+      await fastify.register(sseRoutes);
+      fastify.get("/health", async () => {
+        return {
+          status: "ok",
+          version: "0.1.0",
+          uptime: process.uptime(),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      });
+    };
+  }
+});
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/config/loader.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve } from "path";
+import { parse as parseYaml } from "yaml";
+
+// src/config/schema.ts
+import { z } from "zod";
+var endpointConfigSchema = z.object({
+  url: z.string().url(),
+  events: z.array(z.string()).optional(),
+  headers: z.record(z.string()).optional(),
+  timeout_ms: z.number().int().positive().optional(),
+  max_retries: z.number().int().min(0).max(50).optional()
+});
+var sourceConfigSchema = z.object({
+  name: z.string().min(1).regex(/^[a-z0-9-]+$/, "Source name must be lowercase alphanumeric with hyphens"),
+  provider: z.enum(["stripe", "github", "twilio", "shopify", "generic"]).default("generic"),
+  signing_secret: z.string().optional(),
+  endpoints: z.array(endpointConfigSchema).min(1)
+});
+var configSchema = z.object({
+  server: z.object({
+    port: z.number().int().min(1).max(65535).default(9090),
+    host: z.string().default("0.0.0.0")
+  }).default({}),
+  database: z.object({
+    path: z.string().default("./hookdash.db")
+  }).default({}),
+  delivery: z.object({
+    poll_interval: z.number().int().min(100).max(6e4).default(1e3),
+    default_timeout: z.number().int().min(1e3).max(12e4).default(3e4),
+    default_max_retries: z.number().int().min(0).max(50).default(8)
+  }).default({}),
+  sources: z.array(sourceConfigSchema).default([])
+});
+
+// src/config/loader.ts
+function interpolateEnvVars(value) {
+  if (typeof value === "string") {
+    return value.replace(/\$\{([^}]+)\}/g, (_, envKey) => {
+      const envValue = process.env[envKey.trim()];
+      if (envValue === void 0) {
+        console.warn(`[hookdash] Warning: Environment variable "${envKey}" is not set`);
+        return "";
+      }
+      return envValue;
+    });
+  }
+  if (Array.isArray(value)) {
+    return value.map(interpolateEnvVars);
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = interpolateEnvVars(v);
+    }
+    return result;
+  }
+  return value;
+}
+function findConfigFile(customPath) {
+  if (customPath) {
+    const resolved = resolve(customPath);
+    if (existsSync(resolved)) return resolved;
+    throw new Error(`Config file not found: ${resolved}`);
+  }
+  const candidates = [
+    resolve("hookdash.config.yml"),
+    resolve("hookdash.config.yaml"),
+    resolve(".hookdash.yml")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function loadConfig(options = {}) {
+  let rawConfig = {};
+  const configFile = findConfigFile(options.configPath);
+  if (configFile) {
+    const content = readFileSync(configFile, "utf-8");
+    const parsed = parseYaml(content);
+    if (parsed && typeof parsed === "object") {
+      rawConfig = interpolateEnvVars(parsed);
+    }
+    console.log(`[hookdash] Loaded config from ${configFile}`);
+  }
+  if (options.port) {
+    rawConfig.server = { ...rawConfig.server || {}, port: options.port };
+  }
+  if (options.host) {
+    rawConfig.server = { ...rawConfig.server || {}, host: options.host };
+  }
+  if (options.dbPath) {
+    rawConfig.database = { ...rawConfig.database || {}, path: options.dbPath };
+  }
+  const result = configSchema.safeParse(rawConfig);
+  if (!result.success) {
+    const errors = result.error.errors.map((e) => `  - ${e.path.join(".")}: ${e.message}`).join("\n");
+    throw new Error(`Invalid configuration:
+${errors}`);
+  }
+  return result.data;
+}
+
+// src/server.ts
+init_connection();
+import Fastify from "fastify";
+import fastifyCors from "@fastify/cors";
+import fastifyStatic from "@fastify/static";
+import fastifyRawBody from "fastify-raw-body";
+import { resolve as resolve3, dirname as dirname2 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { fileURLToPath } from "url";
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+async function createServer(config) {
+  const app = Fastify({
+    logger: {
+      transport: {
+        target: "pino-pretty",
+        options: {
+          translateTime: "HH:MM:ss",
+          ignore: "pid,hostname"
+        }
+      }
+    },
+    bodyLimit: 10 * 1024 * 1024
+    // 10MB max webhook payload
+  });
+  await app.register(fastifyCors, {
+    origin: true,
+    methods: ["GET", "POST", "PUT", "DELETE"]
+  });
+  await app.register(fastifyRawBody, {
+    field: "rawBody",
+    global: false,
+    encoding: false,
+    // Return Buffer
+    runFirst: true
+  });
+  const db2 = getDatabase(config);
+  seedFromConfig(config);
+  app.decorate("hookdashConfig", config);
+  app.decorate("db", db2);
+  const ingestionRoutes2 = (await Promise.resolve().then(() => (init_routes(), routes_exports))).default;
+  await app.register(ingestionRoutes2);
+  const { apiRoutes: apiRoutes2 } = await Promise.resolve().then(() => (init_routes2(), routes_exports2));
+  await app.register(apiRoutes2, { prefix: "/api" });
+  const dashboardPaths = [
+    resolve3(__dirname, "../dashboard/dist"),
+    // Dev: source tree
+    resolve3(__dirname, "../../dashboard/dist"),
+    // Built: dist/
+    resolve3(dirname2(__dirname), "dashboard/dist")
+    // npm package
+  ];
+  let dashboardPath = null;
+  for (const p of dashboardPaths) {
+    if (existsSync2(p)) {
+      dashboardPath = p;
+      break;
+    }
+  }
+  if (dashboardPath) {
+    await app.register(fastifyStatic, {
+      root: dashboardPath,
+      prefix: "/",
+      wildcard: false
+    });
+    app.setNotFoundHandler((request, reply) => {
+      if (request.url.startsWith("/api/") || request.url.startsWith("/webhook/")) {
+        return reply.status(404).send({ error: "Not found" });
+      }
+      return reply.sendFile("index.html");
+    });
+    console.log(`[hookdash] Dashboard serving from ${dashboardPath}`);
+  } else {
+    console.log("[hookdash] Dashboard not found (run `npm run build:dashboard` to enable)");
+    app.get("/", async (_request, reply) => {
+      return reply.type("text/html").send(`
+        <!DOCTYPE html>
+        <html>
+          <head><title>hookdash</title></head>
+          <body style="font-family:system-ui;background:#0a0a0f;color:#fff;display:flex;align-items:center;justify-content:center;height:100vh;margin:0">
+            <div style="text-align:center">
+              <h1>\u223F hookdash</h1>
+              <p style="color:#888">Dashboard not built. Run <code style="background:#1e1e2e;padding:2px 8px;border-radius:4px">npm run build:dashboard</code></p>
+              <p style="color:#888;margin-top:20px">API available at <a href="/api/health" style="color:#3b82f6">/api/health</a></p>
+            </div>
+          </body>
+        </html>
+      `);
+    });
+  }
+  return app;
+}
+
+// src/index.ts
+init_worker();
+init_connection();
+var program = new Command();
+program.name("hookdash").description("Zero-config, self-hosted webhook gateway with a beautiful dashboard").version("0.1.0");
+program.command("start").description("Start the hookdash server").option("-p, --port <port>", "Server port", parseInt).option("-h, --host <host>", "Server host").option("-c, --config <path>", "Path to config file").option("-d, --db <path>", "Database file path").action(async (options) => {
+  try {
+    console.log("");
+    console.log("  \u223F  hookdash v0.1.0");
+    console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    console.log("");
+    const config = loadConfig({
+      configPath: options.config,
+      port: options.port,
+      host: options.host,
+      dbPath: options.db
+    });
+    const app = await createServer(config);
+    const worker = new DeliveryWorker(config);
+    worker.start();
+    const shutdown = async (signal) => {
+      console.log(`
+[hookdash] ${signal} received, shutting down...`);
+      worker.stop();
+      await app.close();
+      closeDatabase();
+      console.log("[hookdash] Goodbye! \u{1F44B}");
+      process.exit(0);
+    };
+    process.on("SIGINT", () => shutdown("SIGINT"));
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+    await app.listen({
+      port: config.server.port,
+      host: config.server.host
+    });
+    console.log("");
+    console.log(`  \u{1FA9D} Webhook endpoint: http://${config.server.host === "0.0.0.0" ? "localhost" : config.server.host}:${config.server.port}/webhook/:source`);
+    console.log(`  \u{1F4CA} Dashboard:        http://${config.server.host === "0.0.0.0" ? "localhost" : config.server.host}:${config.server.port}`);
+    console.log(`  \u{1F4E1} API:              http://${config.server.host === "0.0.0.0" ? "localhost" : config.server.host}:${config.server.port}/api/health`);
+    console.log("");
+    if (config.sources.length === 0) {
+      console.log("  \u2139  No sources configured. Create a hookdash.config.yml to get started.");
+      console.log("     See: https://github.com/hookdash/hookdash#configuration");
+      console.log("");
+    }
+  } catch (err) {
+    console.error("[hookdash] Failed to start:", err.message);
+    process.exit(1);
+  }
+});
+program.command("init").description("Create an example hookdash.config.yml in the current directory").action(async () => {
+  const { writeFileSync, existsSync: existsSync3 } = await import("fs");
+  const configPath = "hookdash.config.yml";
+  if (existsSync3(configPath)) {
+    console.log(`[hookdash] ${configPath} already exists. Skipping.`);
+    return;
+  }
+  const exampleConfig = `# hookdash configuration
+# Docs: https://github.com/hookdash/hookdash#configuration
+
+server:
+  port: 9090
+  host: 0.0.0.0
+
+database:
+  path: ./hookdash.db
+
+delivery:
+  poll_interval: 1000        # ms between delivery polls
+  default_timeout: 30000     # ms per delivery attempt
+  default_max_retries: 8     # max retries before dead letter
+
+sources:
+  # Stripe webhooks
+  # - name: stripe
+  #   provider: stripe
+  #   signing_secret: \${STRIPE_WEBHOOK_SECRET}
+  #   endpoints:
+  #     - url: http://localhost:3000/api/webhooks/stripe
+  #       events: ["payment_intent.*", "charge.*"]
+
+  # GitHub webhooks
+  # - name: github
+  #   provider: github
+  #   signing_secret: \${GITHUB_WEBHOOK_SECRET}
+  #   endpoints:
+  #     - url: http://localhost:3000/api/webhooks/github
+
+  # Generic webhooks (HMAC-SHA256)
+  - name: my-service
+    provider: generic
+    signing_secret: my-secret-key
+    endpoints:
+      - url: http://localhost:3000/hooks
+`;
+  writeFileSync(configPath, exampleConfig);
+  console.log(`[hookdash] Created ${configPath}`);
+  console.log("[hookdash] Edit it and run: hookdash start");
+});
+program.parse();
+//# sourceMappingURL=index.js.map