@better-webhook/cli 3.4.3 → 3.5.0

package/dist/core/dashboard-api.js

@@ -1,271 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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;
-    };
-}>;

package/dist/core/dashboard-server.js

@@ -1,124 +0,0 @@
-import express from "express";
-import { createServer } from "http";
-import { WebSocketServer } from "ws";
-import path from "path";
-import { existsSync } from "fs";
-import { fileURLToPath } from "url";
-import { createDashboardApiRouter, } from "./dashboard-api.js";
-import { CaptureServer } from "./capture-server.js";
-import { ReplayEngine } from "./replay-engine.js";
-import { TemplateManager } from "./template-manager.js";
-function resolveDashboardDistDir(runtimeDir) {
-    const candidates = [
-        path.resolve(runtimeDir, "dashboard"),
-        path.resolve(runtimeDir, "..", "dashboard"),
-        path.resolve(runtimeDir, "..", "..", "dist", "dashboard"),
-        path.resolve(runtimeDir, "..", "..", "..", "dashboard", "dist"),
-    ];
-    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;
-    const runtimeDir = typeof __dirname !== "undefined"
-        ?
-            __dirname
-        : path.dirname(fileURLToPath(import.meta.url));
-    const { distDir: dashboardDistDir, indexHtml: dashboardIndexHtml } = resolveDashboardDistDir(runtimeDir);
-    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/executor.d.ts

@@ -1,11 +0,0 @@
-import type { WebhookExecutionOptions, WebhookExecutionResult, HeaderEntry, WebhookTemplate } from "../types/index.js";
-export declare function executeWebhook(options: WebhookExecutionOptions): Promise<WebhookExecutionResult>;
-export declare function executeTemplate(template: WebhookTemplate, options?: {
-    url?: string;
-    secret?: string;
-    headers?: HeaderEntry[];
-}): Promise<WebhookExecutionResult>;
-export declare class ExecutionError extends Error {
-    duration: number;
-    constructor(message: string, duration: number);
-}

package/dist/core/executor.js

@@ -1,130 +0,0 @@
-import { request } from "undici";
-import { generateSignature, getProviderHeaders } from "./signature.js";
-export async function executeWebhook(options) {
-    const startTime = Date.now();
-    let bodyStr;
-    if (options.body !== undefined) {
-        bodyStr =
-            typeof options.body === "string"
-                ? options.body
-                : JSON.stringify(options.body);
-    }
-    const headers = {};
-    if (options.provider) {
-        const providerHeaders = getProviderHeaders(options.provider);
-        for (const h of providerHeaders) {
-            headers[h.key] = h.value;
-        }
-    }
-    if (options.headers) {
-        for (const h of options.headers) {
-            headers[h.key] = h.value;
-        }
-    }
-    if (options.secret && options.provider && bodyStr) {
-        const sig = generateSignature(options.provider, bodyStr, options.secret, {
-            url: options.url,
-        });
-        if (sig) {
-            headers[sig.header] = sig.value;
-        }
-    }
-    if (!headers["Content-Type"] && !headers["content-type"]) {
-        headers["Content-Type"] = "application/json";
-    }
-    try {
-        const response = await request(options.url, {
-            method: options.method || "POST",
-            headers,
-            body: bodyStr,
-            headersTimeout: options.timeout || 30000,
-            bodyTimeout: options.timeout || 30000,
-        });
-        const bodyText = await response.body.text();
-        const duration = Date.now() - startTime;
-        const responseHeaders = {};
-        for (const [key, value] of Object.entries(response.headers)) {
-            if (value !== undefined) {
-                responseHeaders[key] = value;
-            }
-        }
-        let json;
-        try {
-            json = JSON.parse(bodyText);
-        }
-        catch {
-        }
-        return {
-            status: response.statusCode,
-            statusText: getStatusText(response.statusCode),
-            headers: responseHeaders,
-            body: json ?? bodyText,
-            bodyText,
-            json,
-            duration,
-        };
-    }
-    catch (error) {
-        const duration = Date.now() - startTime;
-        throw new ExecutionError(error.message, duration);
-    }
-}
-export async function executeTemplate(template, options = {}) {
-    const targetUrl = options.url || template.url;
-    if (!targetUrl) {
-        throw new Error("No target URL specified. Use --url or set url in template.");
-    }
-    const mergedHeaders = [...(template.headers || [])];
-    if (options.headers) {
-        for (const h of options.headers) {
-            const existingIdx = mergedHeaders.findIndex((mh) => mh.key.toLowerCase() === h.key.toLowerCase());
-            if (existingIdx >= 0) {
-                mergedHeaders[existingIdx] = h;
-            }
-            else {
-                mergedHeaders.push(h);
-            }
-        }
-    }
-    return executeWebhook({
-        url: targetUrl,
-        method: template.method,
-        headers: mergedHeaders,
-        body: template.body,
-        secret: options.secret,
-        provider: template.provider,
-    });
-}
-export class ExecutionError extends Error {
-    duration;
-    constructor(message, duration) {
-        super(message);
-        this.name = "ExecutionError";
-        this.duration = duration;
-    }
-}
-function getStatusText(code) {
-    const statusTexts = {
-        200: "OK",
-        201: "Created",
-        202: "Accepted",
-        204: "No Content",
-        301: "Moved Permanently",
-        302: "Found",
-        304: "Not Modified",
-        400: "Bad Request",
-        401: "Unauthorized",
-        403: "Forbidden",
-        404: "Not Found",
-        405: "Method Not Allowed",
-        408: "Request Timeout",
-        409: "Conflict",
-        422: "Unprocessable Entity",
-        429: "Too Many Requests",
-        500: "Internal Server Error",
-        502: "Bad Gateway",
-        503: "Service Unavailable",
-        504: "Gateway Timeout",
-    };
-    return statusTexts[code] || "Unknown";
-}

package/dist/core/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./template-manager.js";
-export * from "./signature.js";
-export * from "./capture-server.js";
-export * from "./replay-engine.js";
-export * from "./executor.js";

package/dist/core/index.js

@@ -1,5 +0,0 @@
-export * from "./template-manager.js";
-export * from "./signature.js";
-export * from "./capture-server.js";
-export * from "./replay-engine.js";
-export * from "./executor.js";

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

@@ -1,18 +0,0 @@
-import type { CaptureFile, ReplayOptions, WebhookExecutionResult, WebhookTemplate } from "../types/index.js";
-export declare class ReplayEngine {
-    private capturesDir;
-    constructor(capturesDir?: string);
-    getCapturesDir(): string;
-    listCaptures(limit?: number): CaptureFile[];
-    getCapture(captureId: string): CaptureFile | null;
-    replay(captureId: string, options: ReplayOptions): Promise<WebhookExecutionResult>;
-    captureToTemplate(captureId: string, options?: {
-        url?: string;
-    }): WebhookTemplate;
-    getCaptureSummary(captureId: string): string;
-    searchCaptures(query: string): CaptureFile[];
-    getCapturesByProvider(provider: string): CaptureFile[];
-    deleteCapture(captureId: string): boolean;
-    deleteAllCaptures(): number;
-}
-export declare function getReplayEngine(capturesDir?: string): ReplayEngine;