@better-webhook/cli 3.9.0 → 3.10.0

package/dist/commands/run.js

@@ -0,0 +1,182 @@
+import { Command } from "commander";
+import ora from "ora";
+import prompts from "prompts";
+import chalk from "chalk";
+import { getTemplateManager } from "../core/template-manager.js";
+import { executeTemplate } from "../core/executor.js";
+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",
+        recall: "RECALL_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";
+}
+export const run = new Command()
+    .name("run")
+    .argument("[templateId]", "Template ID to run")
+    .description("Run a webhook template against a target URL")
+    .requiredOption("-u, --url <url>", "Target URL to send the webhook to")
+    .option("-s, --secret <secret>", "Secret for signature generation")
+    .option("-H, --header <header>", "Add custom header (format: key:value)", (value, previous) => {
+    const [key, ...valueParts] = value.split(":");
+    const headerValue = valueParts.join(":");
+    if (!key || !headerValue) {
+        throw new Error("Header format should be key:value");
+    }
+    return (previous || []).concat([
+        { key: key.trim(), value: headerValue.trim() },
+    ]);
+}, [])
+    .option("-v, --verbose", "Show detailed request/response information")
+    .action(async (templateId, options) => {
+    const manager = getTemplateManager();
+    if (!templateId) {
+        const spinner = ora("Loading templates...").start();
+        try {
+            const local = manager.listLocalTemplates();
+            const remote = await manager.listRemoteTemplates();
+            spinner.stop();
+            if (local.length === 0 && remote.length === 0) {
+                console.log(chalk.yellow("\n📭 No templates available."));
+                console.log(chalk.gray("   Download templates with: better-webhook templates download\n"));
+                return;
+            }
+            const choices = [];
+            if (local.length > 0) {
+                for (const t of local) {
+                    choices.push({
+                        title: `${t.id} ${chalk.green("(local)")}`,
+                        description: `${t.metadata.provider} - ${t.metadata.event}`,
+                        value: t.id,
+                    });
+                }
+            }
+            const remoteOnly = remote.filter((t) => !t.isDownloaded);
+            for (const t of remoteOnly) {
+                choices.push({
+                    title: `${t.metadata.id} ${chalk.gray("(remote)")}`,
+                    description: `${t.metadata.provider} - ${t.metadata.event}`,
+                    value: `remote:${t.metadata.id}`,
+                });
+            }
+            const response = await prompts({
+                type: "select",
+                name: "templateId",
+                message: "Select a template to run:",
+                choices,
+            });
+            if (!response.templateId) {
+                console.log(chalk.yellow("Cancelled"));
+                return;
+            }
+            templateId = response.templateId;
+        }
+        catch (error) {
+            spinner.fail("Failed to load templates");
+            console.error(chalk.red(error.message));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    if (templateId?.startsWith("remote:")) {
+        const remoteId = templateId.replace("remote:", "");
+        const downloadSpinner = ora(`Downloading ${remoteId}...`).start();
+        try {
+            await manager.downloadTemplate(remoteId);
+            downloadSpinner.succeed(`Downloaded ${remoteId}`);
+            templateId = remoteId;
+        }
+        catch (error) {
+            downloadSpinner.fail(`Failed to download: ${error.message}`);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    const localTemplate = manager.getLocalTemplate(templateId);
+    if (!localTemplate) {
+        console.log(chalk.red(`\n❌ Template not found: ${templateId}`));
+        console.log(chalk.gray("   Download it with: better-webhook templates download " +
+            templateId +
+            "\n"));
+        process.exitCode = 1;
+        return;
+    }
+    const targetUrl = options.url;
+    let secret = options?.secret;
+    if (!secret && localTemplate.metadata.provider) {
+        const envVarName = getSecretEnvVarName(localTemplate.metadata.provider);
+        secret = process.env[envVarName];
+    }
+    console.log(chalk.bold("\n🚀 Executing Webhook\n"));
+    console.log(chalk.gray(`   Template: ${templateId}`));
+    console.log(chalk.gray(`   Provider: ${localTemplate.metadata.provider}`));
+    console.log(chalk.gray(`   Event: ${localTemplate.metadata.event}`));
+    console.log(chalk.gray(`   Target: ${targetUrl}`));
+    if (secret) {
+        console.log(chalk.gray(`   Signature: Will be generated`));
+    }
+    else {
+        console.log(chalk.yellow(`   ⚠️  No secret provided - signature will not be generated`));
+    }
+    console.log();
+    const spinner = ora("Sending webhook...").start();
+    try {
+        const result = await executeTemplate(localTemplate.template, {
+            url: targetUrl,
+            secret,
+            headers: options?.header,
+        });
+        spinner.stop();
+        const statusColor = result.status >= 200 && result.status < 300
+            ? chalk.green
+            : result.status >= 400
+                ? chalk.red
+                : chalk.yellow;
+        console.log(chalk.bold("📥 Response\n"));
+        console.log(`   Status: ${statusColor(`${result.status} ${result.statusText}`)}`);
+        console.log(`   Duration: ${chalk.cyan(`${result.duration}ms`)}`);
+        if (options?.verbose) {
+            console.log(chalk.bold("\n   Headers:"));
+            for (const [key, value] of Object.entries(result.headers)) {
+                const headerValue = Array.isArray(value) ? value.join(", ") : value;
+                console.log(chalk.gray(`     ${key}: ${headerValue}`));
+            }
+        }
+        if (result.json !== undefined) {
+            console.log(chalk.bold("\n   Body:"));
+            console.log(chalk.gray(JSON.stringify(result.json, null, 2)
+                .split("\n")
+                .map((l) => `     ${l}`)
+                .join("\n")));
+        }
+        else if (result.bodyText) {
+            console.log(chalk.bold("\n   Body:"));
+            const preview = result.bodyText.length > 500
+                ? result.bodyText.slice(0, 500) + "..."
+                : result.bodyText;
+            console.log(chalk.gray(`     ${preview}`));
+        }
+        console.log();
+        if (result.status >= 200 && result.status < 300) {
+            console.log(chalk.green("✓ Webhook delivered successfully\n"));
+        }
+        else {
+            console.log(chalk.yellow(`⚠ Webhook delivered with status ${result.status}\n`));
+        }
+    }
+    catch (error) {
+        spinner.fail("Request failed");
+        console.error(chalk.red(`\n❌ ${error.message}\n`));
+        process.exitCode = 1;
+    }
+});

package/dist/commands/templates.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const templates: Command;

package/dist/commands/templates.js

@@ -0,0 +1,285 @@
+import { Command } from "commander";
+import ora from "ora";
+import prompts from "prompts";
+import chalk from "chalk";
+import { getTemplateManager } from "../core/template-manager.js";
+const listCommand = new Command()
+    .name("list")
+    .alias("ls")
+    .description("List available remote templates from the repository")
+    .option("-p, --provider <provider>", "Filter by provider (stripe, github, etc.)")
+    .option("-r, --refresh", "Force refresh the template index cache")
+    .action(async (options) => {
+    const spinner = ora("Fetching remote templates...").start();
+    try {
+        const manager = getTemplateManager();
+        const templates = await manager.listRemoteTemplates({
+            forceRefresh: !!options.refresh,
+        });
+        spinner.stop();
+        if (templates.length === 0) {
+            console.log(chalk.yellow("📭 No remote templates found."));
+            return;
+        }
+        let filtered = templates;
+        if (options.provider) {
+            filtered = templates.filter((t) => t.metadata.provider.toLowerCase() ===
+                options.provider?.toLowerCase());
+        }
+        if (filtered.length === 0) {
+            console.log(chalk.yellow(`📭 No templates found for provider: ${options.provider}`));
+            return;
+        }
+        console.log(chalk.bold("\n📦 Available Templates\n"));
+        const byProvider = new Map();
+        for (const t of filtered) {
+            const provider = t.metadata.provider;
+            if (!byProvider.has(provider)) {
+                byProvider.set(provider, []);
+            }
+            byProvider.get(provider).push(t);
+        }
+        for (const [provider, providerTemplates] of byProvider) {
+            console.log(chalk.cyan.bold(`  ${provider.toUpperCase()}`));
+            for (const t of providerTemplates) {
+                const status = t.isDownloaded
+                    ? chalk.green("✓ downloaded")
+                    : chalk.gray("○ remote");
+                console.log(`    ${chalk.white(t.metadata.id)} ${status}`);
+                if (t.metadata.description) {
+                    console.log(chalk.gray(`      ${t.metadata.description}`));
+                }
+            }
+            console.log();
+        }
+        console.log(chalk.gray(`  Total: ${filtered.length} templates`));
+        console.log(chalk.gray(`  Download: better-webhook templates download <id>\n`));
+    }
+    catch (error) {
+        spinner.fail("Failed to fetch templates");
+        console.error(chalk.red(error.message));
+        process.exitCode = 1;
+    }
+});
+const downloadCommand = new Command()
+    .name("download")
+    .alias("get")
+    .argument("[templateId]", "Template ID to download")
+    .description("Download a template to local storage")
+    .option("-a, --all", "Download all available templates")
+    .option("-r, --refresh", "Force refresh the template index cache")
+    .action(async (templateId, options) => {
+    const manager = getTemplateManager();
+    if (options?.all) {
+        const spinner = ora("Fetching template list...").start();
+        try {
+            const templates = await manager.listRemoteTemplates({
+                forceRefresh: true,
+            });
+            const toDownload = templates.filter((t) => !t.isDownloaded);
+            spinner.stop();
+            if (toDownload.length === 0) {
+                console.log(chalk.green("✓ All templates already downloaded"));
+                return;
+            }
+            console.log(chalk.bold(`\nDownloading ${toDownload.length} templates...\n`));
+            for (const t of toDownload) {
+                const downloadSpinner = ora(`Downloading ${t.metadata.id}...`).start();
+                try {
+                    await manager.downloadTemplate(t.metadata.id);
+                    downloadSpinner.succeed(`Downloaded ${t.metadata.id}`);
+                }
+                catch (error) {
+                    downloadSpinner.fail(`Failed: ${t.metadata.id} - ${error.message}`);
+                }
+            }
+            console.log(chalk.green("\n✓ Download complete\n"));
+        }
+        catch (error) {
+            spinner.fail("Failed to fetch templates");
+            console.error(chalk.red(error.message));
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (!templateId) {
+        const spinner = ora("Fetching templates...").start();
+        try {
+            const templates = await manager.listRemoteTemplates({
+                forceRefresh: !!options?.refresh,
+            });
+            spinner.stop();
+            const notDownloaded = templates.filter((t) => !t.isDownloaded);
+            if (notDownloaded.length === 0) {
+                console.log(chalk.green("✓ All templates already downloaded"));
+                return;
+            }
+            const choices = notDownloaded.map((t) => ({
+                title: t.metadata.id,
+                description: `${t.metadata.provider} - ${t.metadata.event}`,
+                value: t.metadata.id,
+            }));
+            const response = await prompts({
+                type: "select",
+                name: "templateId",
+                message: "Select a template to download:",
+                choices,
+            });
+            if (!response.templateId) {
+                console.log(chalk.yellow("Cancelled"));
+                return;
+            }
+            templateId = response.templateId;
+        }
+        catch (error) {
+            spinner.fail("Failed to fetch templates");
+            console.error(chalk.red(error.message));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    const spinner = ora(`Downloading ${templateId}...`).start();
+    try {
+        const template = await manager.downloadTemplate(templateId);
+        spinner.succeed(`Downloaded ${templateId}`);
+        console.log(chalk.gray(`  Saved to: ${template.filePath}`));
+        console.log(chalk.gray(`  Run with: better-webhook run ${templateId}\n`));
+    }
+    catch (error) {
+        spinner.fail(`Failed to download ${templateId}`);
+        console.error(chalk.red(error.message));
+        process.exitCode = 1;
+    }
+});
+const localCommand = new Command()
+    .name("local")
+    .description("List downloaded local templates")
+    .option("-p, --provider <provider>", "Filter by provider")
+    .action((options) => {
+    const manager = getTemplateManager();
+    let templates = manager.listLocalTemplates();
+    if (options.provider) {
+        templates = templates.filter((t) => t.metadata.provider.toLowerCase() === options.provider?.toLowerCase());
+    }
+    if (templates.length === 0) {
+        console.log(chalk.yellow("\n📭 No local templates found."));
+        console.log(chalk.gray("   Download templates with: better-webhook templates download\n"));
+        return;
+    }
+    console.log(chalk.bold("\n📁 Local Templates\n"));
+    const byProvider = new Map();
+    for (const t of templates) {
+        const provider = t.metadata.provider;
+        if (!byProvider.has(provider)) {
+            byProvider.set(provider, []);
+        }
+        byProvider.get(provider).push(t);
+    }
+    for (const [provider, providerTemplates] of byProvider) {
+        console.log(chalk.cyan.bold(`  ${provider.toUpperCase()}`));
+        for (const t of providerTemplates) {
+            console.log(`    ${chalk.white(t.id)}`);
+            console.log(chalk.gray(`      Event: ${t.metadata.event}`));
+            console.log(chalk.gray(`      Downloaded: ${new Date(t.downloadedAt).toLocaleDateString()}`));
+        }
+        console.log();
+    }
+    console.log(chalk.gray(`  Total: ${templates.length} templates`));
+    console.log(chalk.gray(`  Storage: ${manager.getTemplatesDir()}\n`));
+});
+const searchCommand = new Command()
+    .name("search")
+    .argument("<query>", "Search query")
+    .description("Search templates by name, provider, or event")
+    .action(async (query) => {
+    const spinner = ora("Searching...").start();
+    try {
+        const manager = getTemplateManager();
+        const results = await manager.searchTemplates(query);
+        spinner.stop();
+        const totalCount = results.remote.length + results.local.length;
+        if (totalCount === 0) {
+            console.log(chalk.yellow(`\n📭 No templates found for: "${query}"\n`));
+            return;
+        }
+        console.log(chalk.bold(`\n🔍 Search Results for "${query}"\n`));
+        if (results.local.length > 0) {
+            console.log(chalk.cyan.bold("  LOCAL TEMPLATES"));
+            for (const t of results.local) {
+                console.log(`    ${chalk.green("✓")} ${t.id} (${t.metadata.provider})`);
+            }
+            console.log();
+        }
+        if (results.remote.length > 0) {
+            console.log(chalk.cyan.bold("  REMOTE TEMPLATES"));
+            for (const t of results.remote) {
+                const status = t.isDownloaded ? chalk.green("✓") : chalk.gray("○");
+                console.log(`    ${status} ${t.metadata.id} (${t.metadata.provider})`);
+            }
+            console.log();
+        }
+        console.log(chalk.gray(`  Found: ${totalCount} templates\n`));
+    }
+    catch (error) {
+        spinner.fail("Search failed");
+        console.error(chalk.red(error.message));
+        process.exitCode = 1;
+    }
+});
+const cacheCommand = new Command()
+    .name("cache")
+    .description("Manage template cache")
+    .option("-c, --clear", "Clear the template cache")
+    .action((options) => {
+    if (options.clear) {
+        const manager = getTemplateManager();
+        manager.clearCache();
+        console.log(chalk.green("✓ Template cache cleared"));
+    }
+    else {
+        console.log("Use --clear to clear the template cache");
+    }
+});
+const cleanCommand = new Command()
+    .name("clean")
+    .alias("remove-all")
+    .description("Remove all downloaded templates")
+    .option("-f, --force", "Skip confirmation prompt")
+    .action(async (options) => {
+    const manager = getTemplateManager();
+    const templates = manager.listLocalTemplates();
+    if (templates.length === 0) {
+        console.log(chalk.yellow("\n📭 No local templates to remove.\n"));
+        return;
+    }
+    console.log(chalk.bold(`\n🗑️  Found ${templates.length} downloaded template(s)\n`));
+    for (const t of templates) {
+        console.log(chalk.gray(`    ${t.id} (${t.metadata.provider})`));
+    }
+    console.log();
+    if (!options.force) {
+        const response = await prompts({
+            type: "confirm",
+            name: "confirm",
+            message: `Delete all ${templates.length} template(s)?`,
+            initial: false,
+        });
+        if (!response.confirm) {
+            console.log(chalk.yellow("Cancelled"));
+            return;
+        }
+    }
+    const deleted = manager.deleteAllLocalTemplates();
+    console.log(chalk.green(`\n✓ Removed ${deleted} template(s)`));
+    console.log(chalk.gray(`  Storage: ${manager.getTemplatesDir()}\n`));
+});
+export const templates = new Command()
+    .name("templates")
+    .alias("t")
+    .description("Manage webhook templates")
+    .addCommand(listCommand)
+    .addCommand(downloadCommand)
+    .addCommand(localCommand)
+    .addCommand(searchCommand)
+    .addCommand(cacheCommand)
+    .addCommand(cleanCommand);

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

@@ -0,0 +1,37 @@
+import type { CapturedWebhook, CaptureFile } from "../types/index.js";
+export interface CaptureServerOptions {
+    capturesDir?: string;
+    verbose?: boolean;
+    enableWebSocket?: boolean;
+    onCapture?: (args: {
+        file: string;
+        capture: CapturedWebhook;
+    }) => void;
+}
+export declare class CaptureServer {
+    private server;
+    private wss;
+    private capturesDir;
+    private clients;
+    private captureCount;
+    private enableWebSocket;
+    private onCapture?;
+    private verbose;
+    constructor(options?: string | CaptureServerOptions);
+    getCapturesDir(): string;
+    start(port?: number, host?: string): Promise<number>;
+    stop(): Promise<void>;
+    private handleRequest;
+    private detectProvider;
+    private broadcast;
+    private hasStandardWebhookHeaders;
+    private hasRecallStandardWebhookShape;
+    private hasRecallResourceKeys;
+    private headerIncludes;
+    private sendToClient;
+    listCaptures(limit?: number): CaptureFile[];
+    getCapture(captureId: string): CaptureFile | null;
+    deleteCapture(captureId: string): boolean;
+    getClientCount(): number;
+}
+export declare function getCaptureServer(capturesDir?: string): CaptureServer;