@better-webhook/cli 3.9.0 → 3.10.0

package/dist/core/dashboard-api.js

@@ -0,0 +1,333 @@
+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",
+        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";
+}
+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 TemplateIdSchema = z
+    .string()
+    .regex(/^[a-z0-9][a-z0-9._-]*$/i, "ID must start with alphanumeric and contain only letters, numbers, dots, underscores, and hyphens")
+    .max(128, "ID must be 128 characters or less")
+    .refine((val) => !val.includes("/") && !val.includes("\\") && !val.includes(".."), "ID cannot contain path separators or parent directory references");
+const RunTemplateBodySchema = z.object({
+    templateId: z.string().min(1),
+    url: z.string().min(1),
+    secret: z.string().optional(),
+    headers: z.array(HeaderEntrySchema).optional(),
+});
+const SaveAsTemplateBodySchema = z.object({
+    captureId: z.string().min(1),
+    id: TemplateIdSchema.optional(),
+    name: z.string().optional(),
+    event: z.string().optional(),
+    description: z.string().optional(),
+    url: z.string().optional(),
+    overwrite: z.boolean().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;
+        try {
+            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 },
+            });
+        }
+        catch (error) {
+            console.error("[dashboard-api] Failed to broadcast templates:", error);
+        }
+    };
+    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");
+        }
+    });
+    router.post("/templates/from-capture", express.json({ limit: "5mb" }), async (req, res) => {
+        const parsed = SaveAsTemplateBodySchema.safeParse(req.body);
+        if (!parsed.success) {
+            return jsonError(res, 400, parsed.error.issues[0]?.message || "Invalid body");
+        }
+        const { captureId, id, name, event, description, url, overwrite } = parsed.data;
+        if (url !== undefined) {
+            try {
+                new URL(url);
+            }
+            catch {
+                return jsonError(res, 400, "Invalid url");
+            }
+        }
+        const captureFile = replayEngine.getCapture(captureId);
+        if (!captureFile) {
+            return jsonError(res, 404, "Capture not found");
+        }
+        const template = replayEngine.captureToTemplate(captureId, {
+            url,
+            event,
+        });
+        try {
+            const result = templateManager.saveUserTemplate(template, {
+                id,
+                name,
+                event: event || template.event,
+                description,
+                overwrite,
+            });
+            void broadcastTemplates();
+            return res.json({
+                success: true,
+                id: result.id,
+                filePath: result.filePath,
+                template: result.template,
+            });
+        }
+        catch (error) {
+            return jsonError(res, 400, error?.message || "Failed to save template");
+        }
+    });
+    return router;
+}

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

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

package/dist/core/dashboard-server.js

@@ -0,0 +1,224 @@
+import express from "express";
+import { createServer } from "http";
+import { WebSocketServer } from "ws";
+import path from "path";
+import { existsSync, readFileSync } from "fs";
+import { createDashboardApiRouter, } from "./dashboard-api.js";
+import { CaptureServer } from "./capture-server.js";
+import { ReplayEngine } from "./replay-engine.js";
+import { TemplateManager } from "./template-manager.js";
+import { findCliPackageRoot, resolveRuntimeDir } from "./runtime-paths.js";
+function isStandaloneBinary() {
+    if (typeof STANDALONE_BINARY !== "undefined" && STANDALONE_BINARY) {
+        return true;
+    }
+    if (typeof globalThis.embeddedDashboardFiles !== "undefined" &&
+        globalThis.embeddedDashboardFiles) {
+        return true;
+    }
+    return false;
+}
+function getMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const mimeTypes = {
+        ".html": "text/html; charset=utf-8",
+        ".js": "application/javascript; charset=utf-8",
+        ".css": "text/css; charset=utf-8",
+        ".json": "application/json; charset=utf-8",
+        ".png": "image/png",
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".gif": "image/gif",
+        ".svg": "image/svg+xml",
+        ".ico": "image/x-icon",
+        ".woff": "font/woff",
+        ".woff2": "font/woff2",
+        ".ttf": "font/ttf",
+        ".eot": "application/vnd.ms-fontobject",
+    };
+    return mimeTypes[ext] || "application/octet-stream";
+}
+function createEmbeddedDashboardMiddleware() {
+    const filePathMap = new Map();
+    let indexHtmlPath = null;
+    if (typeof globalThis.embeddedDashboardFiles !== "undefined") {
+        for (const [key, filePath] of Object.entries(globalThis.embeddedDashboardFiles)) {
+            const servePath = "/" + key.replace(/^dashboard\//, "");
+            filePathMap.set(servePath, filePath);
+            if (servePath === "/index.html") {
+                indexHtmlPath = filePath;
+            }
+        }
+    }
+    const staticMiddleware = async (req, res, next) => {
+        if (!Bun) {
+            return next();
+        }
+        const requestPath = req.path === "/" ? "/index.html" : req.path;
+        const filePath = filePathMap.get(requestPath);
+        if (filePath) {
+            try {
+                const file = Bun.file(filePath);
+                const content = await file.arrayBuffer();
+                res.setHeader("Content-Type", getMimeType(requestPath));
+                res.setHeader("Content-Length", content.byteLength);
+                res.send(Buffer.from(content));
+            }
+            catch (err) {
+                console.error(`Failed to serve embedded file ${requestPath}:`, err);
+                next();
+            }
+        }
+        else {
+            next();
+        }
+    };
+    const spaFallback = async (req, res, next) => {
+        if (req.path.startsWith("/api") || req.path === "/health") {
+            return next();
+        }
+        if (!Bun || !indexHtmlPath) {
+            return next();
+        }
+        try {
+            const file = Bun.file(indexHtmlPath);
+            const content = await file.arrayBuffer();
+            res.setHeader("Content-Type", "text/html; charset=utf-8");
+            res.setHeader("Content-Length", content.byteLength);
+            res.send(Buffer.from(content));
+        }
+        catch {
+            next();
+        }
+    };
+    return { staticMiddleware, spaFallback };
+}
+function resolveDashboardDistDir(runtimeDir, options = {}) {
+    const runtimePackageRoot = findCliPackageRoot(runtimeDir);
+    const includePackageRootDistCandidate = runtimePackageRoot !== undefined && runtimePackageRoot === runtimeDir;
+    const candidates = [
+        ...(includePackageRootDistCandidate
+            ? [path.resolve(runtimeDir, "dist", "dashboard")]
+            : []),
+        path.resolve(runtimeDir, "dashboard"),
+        path.resolve(runtimeDir, "..", "dashboard"),
+        path.resolve(runtimeDir, "..", "dist", "dashboard"),
+        path.resolve(runtimeDir, "..", "..", "dist", "dashboard"),
+        path.resolve(runtimeDir, "..", "dashboard", "dist"),
+        path.resolve(runtimeDir, "..", "..", "dashboard", "dist"),
+        path.resolve(runtimeDir, "..", "..", "..", "dashboard", "dist"),
+    ];
+    if (options.verbose) {
+        console.debug(`[dashboard] dist resolution candidates: ${candidates.join(", ")}`);
+    }
+    for (const distDir of candidates) {
+        const indexHtml = path.join(distDir, "index.html");
+        if (existsSync(indexHtml)) {
+            return { distDir, indexHtml };
+        }
+    }
+    const details = candidates.map((p) => `- ${p}`).join("\n");
+    throw new Error(`Dashboard UI build output not found.\n` +
+        `Looked in:\n${details}\n\n` +
+        `Build it with:\n` +
+        `- pnpm --filter @better-webhook/dashboard build\n` +
+        `- pnpm --filter @better-webhook/cli build\n`);
+}
+export async function startDashboardServer(options = {}) {
+    const app = express();
+    app.get("/health", (_req, res) => {
+        res.json({ ok: true });
+    });
+    const clients = new Set();
+    const broadcast = (message) => {
+        const data = JSON.stringify(message);
+        for (const client of clients) {
+            if (client.readyState === 1) {
+                client.send(data);
+            }
+        }
+    };
+    app.use("/api", createDashboardApiRouter({
+        capturesDir: options.capturesDir,
+        templatesBaseDir: options.templatesBaseDir,
+        broadcast,
+    }));
+    const host = options.host || "localhost";
+    const port = options.port ?? 4000;
+    if (isStandaloneBinary()) {
+        const { staticMiddleware, spaFallback } = createEmbeddedDashboardMiddleware();
+        app.use(staticMiddleware);
+        app.get("*", spaFallback);
+    }
+    else {
+        const runtimeDir = resolveRuntimeDir();
+        const { distDir: dashboardDistDir, indexHtml: dashboardIndexHtml } = resolveDashboardDistDir(runtimeDir, { verbose: options.verbose });
+        app.use(express.static(dashboardDistDir));
+        app.get("*", (req, res, next) => {
+            if (req.path.startsWith("/api") || req.path === "/health")
+                return next();
+            res.sendFile(dashboardIndexHtml, (err) => {
+                if (err)
+                    next();
+            });
+        });
+    }
+    const server = createServer(app);
+    const wss = new WebSocketServer({ server, path: "/ws" });
+    wss.on("connection", async (ws) => {
+        clients.add(ws);
+        ws.on("close", () => clients.delete(ws));
+        ws.on("error", () => clients.delete(ws));
+        const replayEngine = new ReplayEngine(options.capturesDir);
+        const templateManager = new TemplateManager(options.templatesBaseDir);
+        const captures = replayEngine.listCaptures(200);
+        ws.send(JSON.stringify({
+            type: "captures_updated",
+            payload: { captures, count: captures.length },
+        }));
+        const local = templateManager.listLocalTemplates();
+        let remote = [];
+        try {
+            const index = await templateManager.fetchRemoteIndex(true);
+            const localIds = new Set(local.map((t) => t.id));
+            remote = index.templates.map((metadata) => ({
+                metadata,
+                isDownloaded: localIds.has(metadata.id),
+            }));
+        }
+        catch {
+            remote = [];
+        }
+        ws.send(JSON.stringify({
+            type: "templates_updated",
+            payload: { local, remote },
+        }));
+    });
+    await new Promise((resolve, reject) => {
+        server.listen(port, host, () => resolve());
+        server.on("error", reject);
+    });
+    const url = `http://${host}:${port}`;
+    let capture;
+    const shouldStartCapture = options.startCapture !== false;
+    if (shouldStartCapture) {
+        const captureHost = options.captureHost || "0.0.0.0";
+        const capturePort = options.capturePort ?? 3001;
+        const captureServer = new CaptureServer({
+            capturesDir: options.capturesDir,
+            enableWebSocket: false,
+            onCapture: ({ file, capture }) => {
+                broadcast({
+                    type: "capture",
+                    payload: { file, capture },
+                });
+            },
+        });
+        const actualPort = await captureServer.start(capturePort, captureHost);
+        capture = {
+            server: captureServer,
+            url: `http://${captureHost === "0.0.0.0" ? "localhost" : captureHost}:${actualPort}`,
+        };
+    }
+    return { app, server, url, capture };
+}

package/dist/core/debug-output.d.ts

@@ -0,0 +1,3 @@
+import type { DebugVerifyResult } from "./debug-verify.js";
+export declare function formatDebugOutput(result: DebugVerifyResult): string;
+export declare function printDebugOutput(result: DebugVerifyResult): void;

package/dist/core/debug-output.js

@@ -0,0 +1,69 @@
+import chalk from "chalk";
+function truncate(str, maxLength) {
+    if (str.length <= maxLength)
+        return str;
+    return str.slice(0, maxLength - 3) + "...";
+}
+export function formatDebugOutput(result) {
+    const lines = [];
+    const divider = chalk.gray("─".repeat(60));
+    const header = chalk.bold.cyan("Webhook Verification Debug");
+    lines.push("");
+    lines.push(divider);
+    lines.push(header);
+    lines.push(divider);
+    lines.push(`${chalk.gray("Provider:")}         ${chalk.yellow(result.provider)}`);
+    lines.push(`${chalk.gray("Algorithm:")}        ${chalk.white(result.algorithm)}`);
+    lines.push(`${chalk.gray("Signature Header:")} ${chalk.white(result.headerName)}`);
+    if (result.timestamp) {
+        lines.push(`${chalk.gray("Timestamp:")}        ${chalk.white(result.timestamp)}`);
+    }
+    lines.push(divider);
+    lines.push(chalk.gray("Raw Body (first 200 chars):"));
+    const bodyPreview = truncate(result.rawBody, 200);
+    lines.push(chalk.dim(bodyPreview));
+    lines.push(divider);
+    if (result.signedPayload !== result.rawBody) {
+        lines.push(chalk.gray("Signed Payload (first 200 chars):"));
+        const payloadPreview = truncate(result.signedPayload, 200);
+        lines.push(chalk.dim(payloadPreview));
+        lines.push(divider);
+    }
+    else {
+        lines.push(chalk.gray("Signed Payload:    ") + chalk.dim("<same as raw body>"));
+        lines.push(divider);
+    }
+    lines.push(chalk.gray("Signatures:"));
+    const expectedLabel = "  Expected: ";
+    const computedLabel = "  Computed: ";
+    if (result.expectedSignature) {
+        lines.push(chalk.gray(expectedLabel) + chalk.white(result.expectedSignature));
+    }
+    else {
+        lines.push(chalk.gray(expectedLabel) + chalk.red("<missing from request>"));
+    }
+    if (result.isValid) {
+        lines.push(chalk.gray(computedLabel) + chalk.green(result.computedSignature));
+    }
+    else {
+        lines.push(chalk.gray(computedLabel) +
+            chalk.red(result.computedSignature) +
+            chalk.red(" <- MISMATCH"));
+    }
+    lines.push(divider);
+    if (result.error) {
+        lines.push(chalk.red(`Error: ${result.error}`));
+    }
+    else if (result.isValid) {
+        lines.push(chalk.green.bold("Status: VALID"));
+    }
+    else {
+        lines.push(chalk.red.bold("Status: INVALID"));
+    }
+    lines.push(divider);
+    lines.push("");
+    return lines.join("\n");
+}
+export function printDebugOutput(result) {
+    console.log(formatDebugOutput(result));
+}

package/dist/core/debug-verify.d.ts

@@ -0,0 +1,25 @@
+import type { WebhookProvider } from "../types/index.js";
+export interface DebugVerifyResult {
+    provider: WebhookProvider | "unknown";
+    rawBody: string;
+    signedPayload: string;
+    expectedSignature: string | undefined;
+    computedSignature: string;
+    isValid: boolean;
+    algorithm: string;
+    headerName: string;
+    timestamp?: string;
+    error?: string;
+}
+type Headers = Record<string, string | string[] | undefined>;
+export declare function debugGitHubVerify(rawBody: string, headers: Headers, secret: string): DebugVerifyResult;
+export declare function debugRagieVerify(rawBody: string, headers: Headers, secret: string): DebugVerifyResult;
+export declare function debugStripeVerify(rawBody: string, headers: Headers, secret: string): DebugVerifyResult;
+export declare function debugSlackVerify(rawBody: string, headers: Headers, secret: string): DebugVerifyResult;
+export declare function debugLinearVerify(rawBody: string, headers: Headers, secret: string): DebugVerifyResult;
+export declare function debugShopifyVerify(rawBody: string, headers: Headers, secret: string): DebugVerifyResult;
+export declare function detectProviderFromHeaders(headers: Headers): WebhookProvider | undefined;
+export declare function getSecretEnvVar(provider: WebhookProvider): string;
+export declare function resolveSecret(cliSecret: string | undefined, provider: WebhookProvider | undefined): string | undefined;
+export declare function debugVerify(provider: WebhookProvider | undefined, rawBody: string, headers: Headers, secret: string): DebugVerifyResult;
+export {};