@better-webhook/cli 3.9.0 → 3.10.0

package/dist/core/replay-engine.js

@@ -0,0 +1,293 @@
+import { existsSync, readFileSync, readdirSync, unlinkSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { executeWebhook } from "./executor.js";
+export class ReplayEngine {
+    capturesDir;
+    constructor(capturesDir) {
+        this.capturesDir =
+            capturesDir || join(homedir(), ".better-webhook", "captures");
+    }
+    getCapturesDir() {
+        return this.capturesDir;
+    }
+    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);
+        let found = captures.find((c) => c.capture.id === captureId);
+        if (found)
+            return found;
+        found = captures.find((c) => c.file.includes(captureId));
+        if (found)
+            return found;
+        found = captures.find((c) => c.capture.id.startsWith(captureId));
+        return found || null;
+    }
+    async replay(captureId, options) {
+        const captureFile = this.getCapture(captureId);
+        if (!captureFile) {
+            throw new Error(`Capture not found: ${captureId}`);
+        }
+        const { capture } = captureFile;
+        const headers = [];
+        const skipHeaders = [
+            "host",
+            "content-length",
+            "connection",
+            "accept-encoding",
+        ];
+        for (const [key, value] of Object.entries(capture.headers)) {
+            if (!skipHeaders.includes(key.toLowerCase())) {
+                const headerValue = Array.isArray(value) ? value.join(", ") : value;
+                if (headerValue) {
+                    headers.push({ key, value: headerValue });
+                }
+            }
+        }
+        if (options.headers) {
+            for (const h of options.headers) {
+                const existingIdx = headers.findIndex((eh) => eh.key.toLowerCase() === h.key.toLowerCase());
+                if (existingIdx >= 0) {
+                    headers[existingIdx] = h;
+                }
+                else {
+                    headers.push(h);
+                }
+            }
+        }
+        const body = capture.rawBody || capture.body;
+        return executeWebhook({
+            url: options.targetUrl,
+            method: options.method || capture.method,
+            headers,
+            body,
+        });
+    }
+    captureToTemplate(captureId, options) {
+        const captureFile = this.getCapture(captureId);
+        if (!captureFile) {
+            throw new Error(`Capture not found: ${captureId}`);
+        }
+        const { capture } = captureFile;
+        const skipHeaders = [
+            "host",
+            "content-length",
+            "connection",
+            "accept-encoding",
+            "stripe-signature",
+            "x-hub-signature-256",
+            "x-hub-signature",
+            "x-shopify-hmac-sha256",
+            "x-twilio-signature",
+            "x-slack-signature",
+            "svix-signature",
+            "webhook-signature",
+            "linear-signature",
+        ];
+        const headers = [];
+        for (const [key, value] of Object.entries(capture.headers)) {
+            if (!skipHeaders.includes(key.toLowerCase())) {
+                const headerValue = Array.isArray(value) ? value.join(", ") : value;
+                if (headerValue) {
+                    headers.push({ key, value: headerValue });
+                }
+            }
+        }
+        let body;
+        if (capture.body) {
+            body = capture.body;
+        }
+        else if (capture.rawBody) {
+            try {
+                body = JSON.parse(capture.rawBody);
+            }
+            catch {
+                body = capture.rawBody;
+            }
+        }
+        const event = options?.event || this.detectEvent(capture);
+        return {
+            url: options?.url || `http://localhost:3000${capture.path}`,
+            method: capture.method,
+            headers,
+            body,
+            provider: capture.provider,
+            event,
+            description: `Captured ${capture.provider || "webhook"} at ${capture.timestamp}`,
+        };
+    }
+    detectEvent(capture) {
+        const headers = capture.headers;
+        const githubEvent = headers["x-github-event"];
+        if (githubEvent) {
+            return Array.isArray(githubEvent) ? githubEvent[0] : githubEvent;
+        }
+        if (capture.provider === "stripe" && capture.body) {
+            const body = capture.body;
+            if (typeof body.type === "string") {
+                return body.type;
+            }
+        }
+        if (capture.provider === "slack" && capture.body) {
+            const body = capture.body;
+            if (typeof body.type === "string") {
+                return body.type;
+            }
+            const event = body.event;
+            if (event && typeof event.type === "string") {
+                return event.type;
+            }
+        }
+        if (capture.provider === "linear" && capture.body) {
+            const body = capture.body;
+            if (typeof body.type === "string") {
+                return body.type;
+            }
+        }
+        if (capture.provider === "clerk" && capture.body) {
+            const body = capture.body;
+            if (typeof body.type === "string") {
+                return body.type;
+            }
+        }
+        if (capture.provider === "ragie" && capture.body) {
+            const body = capture.body;
+            if (typeof body.type === "string") {
+                return body.type;
+            }
+            if (typeof body.event_type === "string") {
+                return body.event_type;
+            }
+        }
+        if (capture.provider === "recall" && capture.body) {
+            const body = capture.body;
+            if (typeof body.event === "string") {
+                return body.event;
+            }
+        }
+        const shopifyTopic = headers["x-shopify-topic"];
+        if (shopifyTopic) {
+            return Array.isArray(shopifyTopic) ? shopifyTopic[0] : shopifyTopic;
+        }
+        if (capture.provider === "sendgrid" && Array.isArray(capture.body)) {
+            const firstEvent = capture.body[0];
+            if (firstEvent && typeof firstEvent.event === "string") {
+                return firstEvent.event;
+            }
+        }
+        if (capture.provider === "discord" && capture.body) {
+            const body = capture.body;
+            if (typeof body.type === "number") {
+                return `type_${body.type}`;
+            }
+        }
+        if (capture.body && typeof capture.body === "object") {
+            const body = capture.body;
+            if (typeof body.type === "string") {
+                return body.type;
+            }
+            if (typeof body.event_type === "string") {
+                return body.event_type;
+            }
+            if (typeof body.event === "string") {
+                return body.event;
+            }
+            if (typeof body.action === "string") {
+                return body.action;
+            }
+        }
+        return undefined;
+    }
+    getCaptureSummary(captureId) {
+        const captureFile = this.getCapture(captureId);
+        if (!captureFile) {
+            return "Capture not found";
+        }
+        const { capture } = captureFile;
+        const lines = [];
+        lines.push(`ID: ${capture.id}`);
+        lines.push(`Timestamp: ${new Date(capture.timestamp).toLocaleString()}`);
+        lines.push(`Method: ${capture.method}`);
+        lines.push(`Path: ${capture.path}`);
+        if (capture.provider) {
+            lines.push(`Provider: ${capture.provider}`);
+        }
+        lines.push(`Content-Type: ${capture.contentType || "unknown"}`);
+        lines.push(`Body Size: ${capture.contentLength || 0} bytes`);
+        const headerCount = Object.keys(capture.headers).length;
+        lines.push(`Headers: ${headerCount}`);
+        return lines.join("\n");
+    }
+    searchCaptures(query) {
+        const queryLower = query.toLowerCase();
+        const captures = this.listCaptures(1000);
+        return captures.filter((c) => {
+            const { capture } = c;
+            return (capture.id.toLowerCase().includes(queryLower) ||
+                capture.path.toLowerCase().includes(queryLower) ||
+                capture.method.toLowerCase().includes(queryLower) ||
+                capture.provider?.toLowerCase().includes(queryLower) ||
+                c.file.toLowerCase().includes(queryLower));
+        });
+    }
+    getCapturesByProvider(provider) {
+        const captures = this.listCaptures(1000);
+        return captures.filter((c) => c.capture.provider === provider);
+    }
+    deleteCapture(captureId) {
+        const captureFile = this.getCapture(captureId);
+        if (!captureFile) {
+            return false;
+        }
+        try {
+            unlinkSync(join(this.capturesDir, captureFile.file));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    deleteAllCaptures() {
+        if (!existsSync(this.capturesDir)) {
+            return 0;
+        }
+        const files = readdirSync(this.capturesDir).filter((f) => f.endsWith(".json"));
+        let deleted = 0;
+        for (const file of files) {
+            try {
+                unlinkSync(join(this.capturesDir, file));
+                deleted++;
+            }
+            catch {
+            }
+        }
+        return deleted;
+    }
+}
+let instance = null;
+export function getReplayEngine(capturesDir) {
+    if (!instance) {
+        instance = new ReplayEngine(capturesDir);
+    }
+    return instance;
+}

package/dist/core/replay-engine.test.d.ts

@@ -0,0 +1 @@
+export {};