@better-webhook/cli 3.4.4 → 3.5.0

package/dist/core/replay-engine.js

@@ -1,208 +0,0 @@
-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",
-            "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;
-            }
-        }
-        return {
-            url: options?.url || `http://localhost:3000${capture.path}`,
-            method: capture.method,
-            headers,
-            body,
-            provider: capture.provider,
-            description: `Captured ${capture.provider || "webhook"} at ${capture.timestamp}`,
-        };
-    }
-    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/signature.d.ts

@@ -1,24 +0,0 @@
-import type { WebhookProvider, GeneratedSignature, HeaderEntry } from "../types/index.js";
-export declare function generateStripeSignature(payload: string, secret: string, timestamp?: number): GeneratedSignature;
-export declare function generateGitHubSignature(payload: string, secret: string): GeneratedSignature;
-export declare function generateShopifySignature(payload: string, secret: string): GeneratedSignature;
-export declare function generateTwilioSignature(payload: string, secret: string, url: string): GeneratedSignature;
-export declare function generateSlackSignature(payload: string, secret: string, timestamp?: number): GeneratedSignature;
-export declare function generateLinearSignature(payload: string, secret: string): GeneratedSignature;
-export declare function generateClerkSignature(payload: string, secret: string, timestamp?: number, webhookId?: string): GeneratedSignature;
-export declare function generateSendGridSignature(payload: string, secret: string, timestamp?: number): GeneratedSignature;
-export declare function generateRagieSignature(payload: string, secret: string): GeneratedSignature;
-export declare function generateSignature(provider: WebhookProvider, payload: string, secret: string, options?: {
-    timestamp?: number;
-    url?: string;
-    webhookId?: string;
-}): GeneratedSignature | null;
-export declare function getProviderHeaders(provider: WebhookProvider, options?: {
-    timestamp?: number;
-    webhookId?: string;
-    event?: string;
-}): HeaderEntry[];
-export declare function verifySignature(provider: WebhookProvider, payload: string, signature: string, secret: string, options?: {
-    timestamp?: number;
-    url?: string;
-}): boolean;

package/dist/core/signature.js

@@ -1,199 +0,0 @@
-import { createHmac } from "crypto";
-export function generateStripeSignature(payload, secret, timestamp) {
-    const ts = timestamp || Math.floor(Date.now() / 1000);
-    const signedPayload = `${ts}.${payload}`;
-    const signature = createHmac("sha256", secret)
-        .update(signedPayload)
-        .digest("hex");
-    return {
-        header: "Stripe-Signature",
-        value: `t=${ts},v1=${signature}`,
-    };
-}
-export function generateGitHubSignature(payload, secret) {
-    const signature = createHmac("sha256", secret).update(payload).digest("hex");
-    return {
-        header: "X-Hub-Signature-256",
-        value: `sha256=${signature}`,
-    };
-}
-export function generateShopifySignature(payload, secret) {
-    const signature = createHmac("sha256", secret)
-        .update(payload)
-        .digest("base64");
-    return {
-        header: "X-Shopify-Hmac-SHA256",
-        value: signature,
-    };
-}
-export function generateTwilioSignature(payload, secret, url) {
-    const signatureInput = url + payload;
-    const signature = createHmac("sha1", secret)
-        .update(signatureInput)
-        .digest("base64");
-    return {
-        header: "X-Twilio-Signature",
-        value: signature,
-    };
-}
-export function generateSlackSignature(payload, secret, timestamp) {
-    const ts = timestamp || Math.floor(Date.now() / 1000);
-    const signatureBaseString = `v0:${ts}:${payload}`;
-    const signature = createHmac("sha256", secret)
-        .update(signatureBaseString)
-        .digest("hex");
-    return {
-        header: "X-Slack-Signature",
-        value: `v0=${signature}`,
-    };
-}
-export function generateLinearSignature(payload, secret) {
-    const signature = createHmac("sha256", secret).update(payload).digest("hex");
-    return {
-        header: "Linear-Signature",
-        value: signature,
-    };
-}
-export function generateClerkSignature(payload, secret, timestamp, webhookId) {
-    const ts = timestamp || Math.floor(Date.now() / 1000);
-    const msgId = webhookId || `msg_${Date.now()}`;
-    const signedPayload = `${msgId}.${ts}.${payload}`;
-    const signature = createHmac("sha256", secret)
-        .update(signedPayload)
-        .digest("base64");
-    return {
-        header: "Svix-Signature",
-        value: `v1,${signature}`,
-    };
-}
-export function generateSendGridSignature(payload, secret, timestamp) {
-    const ts = timestamp || Math.floor(Date.now() / 1000);
-    const signedPayload = `${ts}${payload}`;
-    const signature = createHmac("sha256", secret)
-        .update(signedPayload)
-        .digest("base64");
-    return {
-        header: "X-Twilio-Email-Event-Webhook-Signature",
-        value: signature,
-    };
-}
-export function generateRagieSignature(payload, secret) {
-    const signature = createHmac("sha256", secret).update(payload).digest("hex");
-    return {
-        header: "X-Signature",
-        value: signature,
-    };
-}
-export function generateSignature(provider, payload, secret, options) {
-    const timestamp = options?.timestamp;
-    switch (provider) {
-        case "stripe":
-            return generateStripeSignature(payload, secret, timestamp);
-        case "github":
-            return generateGitHubSignature(payload, secret);
-        case "shopify":
-            return generateShopifySignature(payload, secret);
-        case "twilio":
-            if (!options?.url) {
-                throw new Error("Twilio signature requires URL");
-            }
-            return generateTwilioSignature(payload, secret, options.url);
-        case "slack":
-            return generateSlackSignature(payload, secret, timestamp);
-        case "linear":
-            return generateLinearSignature(payload, secret);
-        case "clerk":
-            return generateClerkSignature(payload, secret, timestamp, options?.webhookId);
-        case "sendgrid":
-            return generateSendGridSignature(payload, secret, timestamp);
-        case "ragie":
-            return generateRagieSignature(payload, secret);
-        case "discord":
-        case "custom":
-        default:
-            return null;
-    }
-}
-export function getProviderHeaders(provider, options) {
-    const headers = [];
-    const timestamp = options?.timestamp || Math.floor(Date.now() / 1000);
-    switch (provider) {
-        case "stripe":
-            headers.push({ key: "Content-Type", value: "application/json" }, {
-                key: "User-Agent",
-                value: "Stripe/1.0 (+https://stripe.com/docs/webhooks)",
-            });
-            break;
-        case "github":
-            headers.push({ key: "Content-Type", value: "application/json" }, { key: "User-Agent", value: "GitHub-Hookshot/better-webhook" }, { key: "X-GitHub-Event", value: options?.event || "push" }, {
-                key: "X-GitHub-Delivery",
-                value: options?.webhookId || generateDeliveryId(),
-            });
-            break;
-        case "shopify":
-            headers.push({ key: "Content-Type", value: "application/json" }, { key: "X-Shopify-Topic", value: options?.event || "orders/create" }, { key: "X-Shopify-Shop-Domain", value: "example.myshopify.com" }, { key: "X-Shopify-API-Version", value: "2024-01" });
-            break;
-        case "slack":
-            headers.push({ key: "Content-Type", value: "application/json" }, { key: "X-Slack-Request-Timestamp", value: String(timestamp) });
-            break;
-        case "clerk":
-            headers.push({ key: "Content-Type", value: "application/json" }, { key: "Svix-Id", value: options?.webhookId || `msg_${Date.now()}` }, { key: "Svix-Timestamp", value: String(timestamp) });
-            break;
-        case "sendgrid":
-            headers.push({ key: "Content-Type", value: "application/json" }, {
-                key: "X-Twilio-Email-Event-Webhook-Timestamp",
-                value: String(timestamp),
-            });
-            break;
-        case "twilio":
-            headers.push({
-                key: "Content-Type",
-                value: "application/x-www-form-urlencoded",
-            });
-            break;
-        case "linear":
-            headers.push({ key: "Content-Type", value: "application/json" }, {
-                key: "Linear-Delivery",
-                value: options?.webhookId || generateDeliveryId(),
-            });
-            break;
-        case "discord":
-            headers.push({ key: "Content-Type", value: "application/json" }, { key: "User-Agent", value: "Discord-Webhook/1.0" });
-            break;
-        case "ragie":
-            headers.push({ key: "Content-Type", value: "application/json" });
-            break;
-        default:
-            headers.push({ key: "Content-Type", value: "application/json" });
-    }
-    return headers;
-}
-function generateDeliveryId() {
-    const chars = "0123456789abcdef";
-    let id = "";
-    for (let i = 0; i < 36; i++) {
-        if (i === 8 || i === 13 || i === 18 || i === 23) {
-            id += "-";
-        }
-        else {
-            id += chars[Math.floor(Math.random() * chars.length)];
-        }
-    }
-    return id;
-}
-export function verifySignature(provider, payload, signature, secret, options) {
-    const generated = generateSignature(provider, payload, secret, options);
-    if (!generated) {
-        return false;
-    }
-    const a = generated.value;
-    const b = signature;
-    if (a.length !== b.length) {
-        return false;
-    }
-    let result = 0;
-    for (let i = 0; i < a.length; i++) {
-        result |= a.charCodeAt(i) ^ b.charCodeAt(i);
-    }
-    return result === 0;
-}

package/dist/core/template-manager.d.ts

@@ -1,24 +0,0 @@
-import { type TemplatesIndex, type LocalTemplate, type RemoteTemplate } from "../types/index.js";
-export declare class TemplateManager {
-    private baseDir;
-    private templatesDir;
-    private cacheFile;
-    private indexCache;
-    constructor(baseDir?: string);
-    getTemplatesDir(): string;
-    fetchRemoteIndex(forceRefresh?: boolean): Promise<TemplatesIndex>;
-    listRemoteTemplates(options?: {
-        forceRefresh?: boolean;
-    }): Promise<RemoteTemplate[]>;
-    downloadTemplate(templateId: string): Promise<LocalTemplate>;
-    listLocalTemplates(): LocalTemplate[];
-    getLocalTemplate(templateId: string): LocalTemplate | null;
-    deleteLocalTemplate(templateId: string): boolean;
-    searchTemplates(query: string): Promise<{
-        remote: RemoteTemplate[];
-        local: LocalTemplate[];
-    }>;
-    clearCache(): void;
-    deleteAllLocalTemplates(): number;
-}
-export declare function getTemplateManager(baseDir?: string): TemplateManager;