@better-webhook/cli 3.3.0 → 3.4.1

package/dist/core/capture-server.js

@@ -0,0 +1,292 @@
+import { createServer, } from "http";
+import { WebSocketServer } from "ws";
+import { writeFileSync, mkdirSync, existsSync, readdirSync, readFileSync, unlinkSync, } from "fs";
+import { join } from "path";
+import { randomUUID } from "crypto";
+import { homedir } from "os";
+export class CaptureServer {
+    server = null;
+    wss = null;
+    capturesDir;
+    clients = new Set();
+    captureCount = 0;
+    enableWebSocket;
+    onCapture;
+    constructor(options) {
+        const capturesDir = typeof options === "string" ? options : options?.capturesDir;
+        this.capturesDir =
+            capturesDir || join(homedir(), ".better-webhook", "captures");
+        this.enableWebSocket =
+            typeof options === "object" ? options?.enableWebSocket !== false : true;
+        this.onCapture =
+            typeof options === "object" ? options?.onCapture : undefined;
+        if (!existsSync(this.capturesDir)) {
+            mkdirSync(this.capturesDir, { recursive: true });
+        }
+    }
+    getCapturesDir() {
+        return this.capturesDir;
+    }
+    async start(port = 3001, host = "0.0.0.0") {
+        return new Promise((resolve, reject) => {
+            this.server = createServer((req, res) => this.handleRequest(req, res));
+            if (this.enableWebSocket) {
+                this.wss = new WebSocketServer({ server: this.server });
+                this.wss.on("connection", (ws) => {
+                    this.clients.add(ws);
+                    console.log("📡 Dashboard connected via WebSocket");
+                    ws.on("close", () => {
+                        this.clients.delete(ws);
+                        console.log("📡 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(`\n🎣 Webhook Capture Server`);
+                console.log(`   Listening on http://${host === "0.0.0.0" ? "localhost" : host}:${actualPort}`);
+                console.log(`   📁 Captures saved to: ${this.capturesDir}`);
+                console.log(`   💡 Send webhooks to any path to capture them`);
+                if (this.enableWebSocket) {
+                    console.log(`   🌐 WebSocket available for real-time updates`);
+                }
+                console.log(`   ⏹️  Press Ctrl+C to stop\n`);
+                resolve(actualPort);
+            });
+        });
+    }
+    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("\n🛑 Capture server stopped");
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    async handleRequest(req, res) {
+        if (req.headers.upgrade?.toLowerCase() === "websocket") {
+            return;
+        }
+        const timestamp = new Date().toISOString();
+        const id = randomUUID();
+        const url = req.url || "/";
+        const urlParts = new URL(url, `http://${req.headers.host || "localhost"}`);
+        const query = {};
+        for (const [key, value] of urlParts.searchParams.entries()) {
+            if (query[key]) {
+                if (Array.isArray(query[key])) {
+                    query[key].push(value);
+                }
+                else {
+                    query[key] = [query[key], value];
+                }
+            }
+            else {
+                query[key] = value;
+            }
+        }
+        const chunks = [];
+        for await (const chunk of req) {
+            chunks.push(chunk);
+        }
+        const rawBody = Buffer.concat(chunks).toString("utf8");
+        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,
+            path: urlParts.pathname,
+            headers: req.headers,
+            body,
+            rawBody,
+            query,
+            provider,
+            contentType: contentType || undefined,
+            contentLength: rawBody.length,
+        };
+        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 = join(this.capturesDir, filename);
+        try {
+            writeFileSync(filepath, JSON.stringify(captured, null, 2));
+            this.captureCount++;
+            const providerStr = provider ? ` [${provider}]` : "";
+            console.log(`📦 ${req.method} ${urlParts.pathname}${providerStr} -> ${filename}`);
+            this.onCapture?.({ file: filename, capture: captured });
+            if (this.enableWebSocket) {
+                this.broadcast({
+                    type: "capture",
+                    payload: {
+                        file: filename,
+                        capture: captured,
+                    },
+                });
+            }
+        }
+        catch (error) {
+            console.error(`❌ Failed to save capture:`, error);
+        }
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "application/json");
+        res.setHeader("X-Capture-Id", id);
+        res.end(JSON.stringify({
+            success: true,
+            message: "Webhook captured successfully",
+            id,
+            timestamp,
+            file: filename,
+        }));
+    }
+    detectProvider(headers) {
+        if (headers["stripe-signature"]) {
+            return "stripe";
+        }
+        if (headers["x-github-event"] || headers["x-hub-signature-256"]) {
+            return "github";
+        }
+        if (headers["x-ragie-delivery"]) {
+            return "ragie";
+        }
+        if (headers["x-shopify-hmac-sha256"] || headers["x-shopify-topic"]) {
+            return "shopify";
+        }
+        if (headers["x-twilio-signature"]) {
+            return "twilio";
+        }
+        if (headers["x-twilio-email-event-webhook-signature"]) {
+            return "sendgrid";
+        }
+        if (headers["x-slack-signature"]) {
+            return "slack";
+        }
+        if (headers["x-signature-ed25519"]) {
+            return "discord";
+        }
+        if (headers["linear-signature"]) {
+            return "linear";
+        }
+        if (headers["svix-signature"]) {
+            return "clerk";
+        }
+        return undefined;
+    }
+    broadcast(message) {
+        const data = JSON.stringify(message);
+        for (const client of this.clients) {
+            if (client.readyState === 1) {
+                client.send(data);
+            }
+        }
+    }
+    sendToClient(client, message) {
+        if (client.readyState === 1) {
+            client.send(JSON.stringify(message));
+        }
+    }
+    listCaptures(limit = 100) {
+        if (!existsSync(this.capturesDir)) {
+            return [];
+        }
+        const files = readdirSync(this.capturesDir)
+            .filter((f) => f.endsWith(".json"))
+            .sort()
+            .reverse()
+            .slice(0, limit);
+        const captures = [];
+        for (const file of files) {
+            try {
+                const content = readFileSync(join(this.capturesDir, file), "utf-8");
+                const capture = JSON.parse(content);
+                captures.push({ file, capture });
+            }
+            catch {
+            }
+        }
+        return captures;
+    }
+    getCapture(captureId) {
+        const captures = this.listCaptures(1000);
+        return (captures.find((c) => c.capture.id === captureId || c.file.includes(captureId)) || null);
+    }
+    deleteCapture(captureId) {
+        const capture = this.getCapture(captureId);
+        if (!capture) {
+            return false;
+        }
+        try {
+            unlinkSync(join(this.capturesDir, capture.file));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getClientCount() {
+        return this.clients.size;
+    }
+}
+let instance = null;
+export function getCaptureServer(capturesDir) {
+    if (!instance) {
+        instance = new CaptureServer(capturesDir);
+    }
+    return instance;
+}

package/dist/core/dashboard-api.d.ts

@@ -0,0 +1,8 @@
+import express from "express";
+import { type WebSocketMessage } from "../types/index.js";
+export interface DashboardApiOptions {
+    capturesDir?: string;
+    templatesBaseDir?: string;
+    broadcast?: (message: WebSocketMessage) => void;
+}
+export declare function createDashboardApiRouter(options?: DashboardApiOptions): express.Router;

package/dist/core/dashboard-api.js

@@ -0,0 +1,271 @@
+import express from "express";
+import { z } from "zod";
+import { TemplateManager } from "./template-manager.js";
+import { ReplayEngine } from "./replay-engine.js";
+import { executeTemplate } from "./executor.js";
+import { HeaderEntrySchema, HttpMethodSchema, } from "../types/index.js";
+function jsonError(res, status, message) {
+    return res.status(status).json({ error: message });
+}
+function getSecretEnvVarName(provider) {
+    const envVarMap = {
+        github: "GITHUB_WEBHOOK_SECRET",
+        stripe: "STRIPE_WEBHOOK_SECRET",
+        shopify: "SHOPIFY_WEBHOOK_SECRET",
+        twilio: "TWILIO_WEBHOOK_SECRET",
+        ragie: "RAGIE_WEBHOOK_SECRET",
+        slack: "SLACK_WEBHOOK_SECRET",
+        linear: "LINEAR_WEBHOOK_SECRET",
+        clerk: "CLERK_WEBHOOK_SECRET",
+        sendgrid: "SENDGRID_WEBHOOK_SECRET",
+        discord: "DISCORD_WEBHOOK_SECRET",
+        custom: "WEBHOOK_SECRET",
+    };
+    return envVarMap[provider] || "WEBHOOK_SECRET";
+}
+const ReplayBodySchema = z.object({
+    captureId: z.string().min(1),
+    targetUrl: z.string().min(1),
+    method: HttpMethodSchema.optional(),
+    headers: z.array(HeaderEntrySchema).optional(),
+});
+const TemplateDownloadBodySchema = z.object({
+    id: z.string().min(1),
+});
+const RunTemplateBodySchema = z.object({
+    templateId: z.string().min(1),
+    url: z.string().min(1),
+    secret: z.string().optional(),
+    headers: z.array(HeaderEntrySchema).optional(),
+});
+export function createDashboardApiRouter(options = {}) {
+    const router = express.Router();
+    const replayEngine = new ReplayEngine(options.capturesDir);
+    const templateManager = new TemplateManager(options.templatesBaseDir);
+    const broadcast = options.broadcast;
+    const broadcastCaptures = () => {
+        if (!broadcast)
+            return;
+        const captures = replayEngine.listCaptures(200);
+        broadcast({
+            type: "captures_updated",
+            payload: { captures, count: captures.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 > 5000) {
+            return jsonError(res, 400, "Invalid limit");
+        }
+        const q = qRaw.trim();
+        const provider = providerRaw.trim();
+        let captures = q
+            ? replayEngine.searchCaptures(q)
+            : replayEngine.listCaptures(Math.max(limit, 1000));
+        if (provider) {
+            captures = captures.filter((c) => (c.capture.provider || "").toLowerCase() === provider.toLowerCase());
+        }
+        captures = captures.slice(0, limit);
+        return res.json({ captures, count: captures.length });
+    });
+    router.get("/captures/:id", (req, res) => {
+        const id = req.params.id;
+        if (!id) {
+            return jsonError(res, 400, "Missing capture id");
+        }
+        const captureFile = replayEngine.getCapture(id);
+        if (!captureFile) {
+            return jsonError(res, 404, "Capture not found");
+        }
+        return res.json(captureFile);
+    });
+    router.delete("/captures/:id", (req, res) => {
+        const id = req.params.id;
+        if (!id) {
+            return jsonError(res, 400, "Missing capture id");
+        }
+        const deleted = replayEngine.deleteCapture(id);
+        if (!deleted) {
+            return jsonError(res, 404, "Capture not found");
+        }
+        broadcastCaptures();
+        return res.json({ success: true });
+    });
+    router.delete("/captures", (_req, res) => {
+        const deleted = replayEngine.deleteAllCaptures();
+        broadcastCaptures();
+        return res.json({ success: true, deleted });
+    });
+    router.post("/replay", express.json({ limit: "5mb" }), async (req, res) => {
+        const parsed = ReplayBodySchema.safeParse(req.body);
+        if (!parsed.success) {
+            return jsonError(res, 400, parsed.error.issues[0]?.message || "Invalid body");
+        }
+        const { captureId, targetUrl, method, headers } = parsed.data;
+        try {
+            new URL(targetUrl);
+        }
+        catch {
+            return jsonError(res, 400, "Invalid targetUrl");
+        }
+        try {
+            const result = await replayEngine.replay(captureId, {
+                targetUrl,
+                method,
+                headers,
+            });
+            broadcast?.({
+                type: "replay_result",
+                payload: { captureId, targetUrl, result },
+            });
+            return res.json(result);
+        }
+        catch (error) {
+            return jsonError(res, 400, error?.message || "Replay failed");
+        }
+    });
+    router.get("/templates/local", (_req, res) => {
+        const local = templateManager.listLocalTemplates();
+        return res.json({ templates: local, count: local.length });
+    });
+    router.get("/templates/remote", async (req, res) => {
+        const refresh = typeof req.query.refresh === "string"
+            ? req.query.refresh === "1" ||
+                req.query.refresh.toLowerCase() === "true"
+            : false;
+        try {
+            const index = await templateManager.fetchRemoteIndex(refresh);
+            const localIds = new Set(templateManager.listLocalTemplates().map((t) => t.id));
+            const remote = index.templates.map((metadata) => ({
+                metadata,
+                isDownloaded: localIds.has(metadata.id),
+            }));
+            return res.json({ templates: remote, count: remote.length });
+        }
+        catch (error) {
+            return jsonError(res, 500, error?.message || "Failed to fetch remote templates");
+        }
+    });
+    router.post("/templates/download", express.json({ limit: "2mb" }), async (req, res) => {
+        const parsed = TemplateDownloadBodySchema.safeParse(req.body);
+        if (!parsed.success) {
+            return jsonError(res, 400, parsed.error.issues[0]?.message || "Invalid body");
+        }
+        try {
+            const template = await templateManager.downloadTemplate(parsed.data.id);
+            void broadcastTemplates();
+            return res.json({ success: true, template });
+        }
+        catch (error) {
+            return jsonError(res, 400, error?.message || "Download failed");
+        }
+    });
+    router.post("/templates/download-all", express.json({ limit: "1mb" }), async (_req, res) => {
+        try {
+            const index = await templateManager.fetchRemoteIndex(true);
+            const localIds = new Set(templateManager.listLocalTemplates().map((t) => t.id));
+            const toDownload = index.templates.filter((t) => !localIds.has(t.id));
+            const downloaded = [];
+            const failed = [];
+            for (const t of toDownload) {
+                try {
+                    await templateManager.downloadTemplate(t.id);
+                    downloaded.push(t.id);
+                }
+                catch (e) {
+                    failed.push({ id: t.id, error: e?.message || "Failed" });
+                }
+            }
+            return res.json({
+                success: true,
+                total: index.templates.length,
+                downloaded,
+                failed,
+            });
+        }
+        catch (error) {
+            return jsonError(res, 500, error?.message || "Download-all failed");
+        }
+    });
+    router.post("/run", express.json({ limit: "10mb" }), async (req, res) => {
+        const parsed = RunTemplateBodySchema.safeParse(req.body);
+        if (!parsed.success) {
+            return jsonError(res, 400, parsed.error.issues[0]?.message || "Invalid body");
+        }
+        let { templateId, url, secret, headers } = parsed.data;
+        try {
+            new URL(url);
+        }
+        catch {
+            return jsonError(res, 400, "Invalid url");
+        }
+        if (templateId.startsWith("remote:")) {
+            templateId = templateId.slice("remote:".length);
+            try {
+                await templateManager.downloadTemplate(templateId);
+            }
+            catch (error) {
+                return jsonError(res, 400, error?.message || "Failed to download template");
+            }
+        }
+        let localTemplate = templateManager.getLocalTemplate(templateId);
+        if (!localTemplate) {
+            try {
+                await templateManager.downloadTemplate(templateId);
+                localTemplate = templateManager.getLocalTemplate(templateId);
+            }
+            catch {
+            }
+        }
+        if (!localTemplate) {
+            return jsonError(res, 404, "Template not found");
+        }
+        if (!secret && localTemplate.metadata.provider) {
+            const envVarName = getSecretEnvVarName(localTemplate.metadata.provider);
+            secret = process.env[envVarName];
+        }
+        const safeHeaders = headers?.length
+            ? headers
+            : undefined;
+        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;
+}

package/dist/core/dashboard-server.d.ts

@@ -0,0 +1,20 @@
+import express from "express";
+import { type Server } from "http";
+import { type DashboardApiOptions } from "./dashboard-api.js";
+import { CaptureServer } from "./capture-server.js";
+export interface DashboardServerOptions extends DashboardApiOptions {
+    host?: string;
+    port?: number;
+    captureHost?: string;
+    capturePort?: number;
+    startCapture?: boolean;
+}
+export declare function startDashboardServer(options?: DashboardServerOptions): Promise<{
+    app: express.Express;
+    server: Server;
+    url: string;
+    capture?: {
+        server: CaptureServer;
+        url: string;
+    };
+}>;