@sendly/cli 2.2.0 → 2.3.0

package/dist/commands/webhooks/create.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class WebhooksCreate extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        url: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        events: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/webhooks/create.js

@@ -0,0 +1,56 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, warn, json, colors, codeBlock, isJsonMode, } from "../../lib/output.js";
+export default class WebhooksCreate extends AuthenticatedCommand {
+    static description = "Create a webhook";
+    static examples = [
+        '<%= config.bin %> webhooks create --url https://myapp.com/webhook --events message.delivered',
+        '<%= config.bin %> webhooks create --url https://myapp.com/webhook --events message.delivered,message.failed --description "Production webhook"',
+        '<%= config.bin %> webhooks create --url https://webhook.site/abc123 --events message.sent --json',
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        url: Flags.string({
+            char: "u",
+            description: "Webhook URL (must be HTTPS)",
+            required: true,
+        }),
+        events: Flags.string({
+            char: "e",
+            description: "Comma-separated list of events to listen for",
+            required: true,
+        }),
+        description: Flags.string({
+            char: "d",
+            description: "Description for the webhook",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(WebhooksCreate);
+        const events = flags.events.split(",").map(e => e.trim());
+        const response = await apiClient.post("/api/v1/webhooks", {
+            url: flags.url,
+            events,
+            ...(flags.description && { description: flags.description }),
+        });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        success("Webhook created", {
+            ID: response.id,
+            URL: response.url,
+            Events: response.events.join(", "),
+            ...(response.description && { Description: response.description }),
+            Status: response.isActive ? colors.success("active") : colors.warning("inactive"),
+        });
+        console.log();
+        warn("Copy your webhook secret now. You won't be able to see it again!");
+        codeBlock(response.secret);
+        console.log();
+        console.log(colors.dim("Use this secret to verify webhook signatures in your application."));
+        console.log(colors.dim("See the docs for signature verification examples."));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/webhooks/delete.d.ts

@@ -0,0 +1,14 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class WebhooksDelete extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/webhooks/delete.js

@@ -0,0 +1,64 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, error, json, colors, isJsonMode } from "../../lib/output.js";
+import inquirer from "inquirer";
+export default class WebhooksDelete extends AuthenticatedCommand {
+    static description = "Delete a webhook";
+    static examples = [
+        "<%= config.bin %> webhooks delete whk_abc123",
+        "<%= config.bin %> webhooks delete whk_abc123 --yes",
+        "<%= config.bin %> webhooks delete whk_abc123 --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Webhook ID to delete",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        yes: Flags.boolean({
+            char: "y",
+            description: "Skip confirmation prompt",
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WebhooksDelete);
+        // Get webhook details for confirmation
+        let webhook;
+        try {
+            webhook = await apiClient.get(`/api/v1/webhooks/${args.id}`);
+        }
+        catch (err) {
+            error(`Webhook not found: ${args.id}`);
+            this.exit(1);
+        }
+        // Confirm deletion
+        if (!flags.yes && !isJsonMode()) {
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Are you sure you want to delete webhook ${colors.code(args.id)} (${colors.dim(webhook.url)})? This cannot be undone.`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                error("Deletion cancelled");
+                return;
+            }
+        }
+        await apiClient.delete(`/api/v1/webhooks/${args.id}`);
+        if (isJsonMode()) {
+            json({ success: true, webhookId: args.id, deleted: true });
+            return;
+        }
+        success("Webhook deleted", {
+            ID: args.id,
+            URL: webhook.url,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/webhooks/deliveries.d.ts

@@ -0,0 +1,15 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class WebhooksDeliveries extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        limit: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        "failed-only": import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/webhooks/deliveries.js

@@ -0,0 +1,137 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { table, json, info, colors, formatDate, isJsonMode, } from "../../lib/output.js";
+export default class WebhooksDeliveries extends AuthenticatedCommand {
+    static description = "View webhook delivery history";
+    static examples = [
+        "<%= config.bin %> webhooks deliveries whk_abc123",
+        "<%= config.bin %> webhooks deliveries whk_abc123 --limit 20",
+        "<%= config.bin %> webhooks deliveries whk_abc123 --failed-only",
+        "<%= config.bin %> webhooks deliveries whk_abc123 --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Webhook ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        limit: Flags.integer({
+            char: "l",
+            description: "Number of deliveries to show",
+            default: 10,
+        }),
+        "failed-only": Flags.boolean({
+            description: "Show only failed deliveries",
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WebhooksDeliveries);
+        const params = new URLSearchParams({
+            limit: String(flags.limit),
+            ...(flags["failed-only"] && { status: "failed" }),
+        });
+        const deliveries = await apiClient.get(`/api/v1/webhooks/${args.id}/deliveries?${params.toString()}`);
+        if (isJsonMode()) {
+            json(deliveries);
+            return;
+        }
+        if (deliveries.length === 0) {
+            info(flags["failed-only"] ? "No failed deliveries found" : "No deliveries found");
+            return;
+        }
+        console.log();
+        console.log(colors.dim(`Showing ${deliveries.length} deliveries for webhook ${args.id}`));
+        console.log();
+        // Add computed fields for better display
+        const deliveriesWithComputed = deliveries.map(d => ({
+            ...d,
+            attemptDisplay: `${d.attemptNumber}/${d.maxAttempts}`,
+        }));
+        table(deliveriesWithComputed, [
+            {
+                header: "Delivery ID",
+                key: "id",
+                width: 18,
+                formatter: (v) => colors.dim(String(v).slice(0, 15) + "..."),
+            },
+            {
+                header: "Event",
+                key: "eventType",
+                width: 15,
+                formatter: (v) => String(v).replace("message.", ""),
+            },
+            {
+                header: "Status",
+                key: "status",
+                width: 12,
+                formatter: (v) => {
+                    switch (v) {
+                        case "delivered":
+                            return colors.success("delivered");
+                        case "failed":
+                            return colors.error("failed");
+                        case "pending":
+                            return colors.warning("pending");
+                        case "cancelled":
+                            return colors.dim("cancelled");
+                        default:
+                            return String(v);
+                    }
+                },
+            },
+            {
+                header: "Attempt",
+                key: "attemptDisplay",
+                width: 10,
+            },
+            {
+                header: "Status Code",
+                key: "responseStatusCode",
+                width: 12,
+                formatter: (v) => {
+                    if (!v)
+                        return colors.dim("-");
+                    const code = Number(v);
+                    return code >= 200 && code < 300
+                        ? colors.success(String(code))
+                        : colors.error(String(code));
+                },
+            },
+            {
+                header: "Response Time",
+                key: "responseTime",
+                width: 14,
+                formatter: (v) => v ? `${v}ms` : colors.dim("-"),
+            },
+            {
+                header: "Created",
+                key: "createdAt",
+                width: 16,
+                formatter: (v) => formatDate(String(v)),
+            },
+        ]);
+        // Show failed delivery details
+        const failed = deliveries.filter(d => d.status === "failed" && d.errorMessage);
+        if (failed.length > 0 && !flags["failed-only"]) {
+            console.log();
+            console.log(colors.error("Failed deliveries:"));
+            failed.forEach(delivery => {
+                console.log(colors.dim(`  ${delivery.id.slice(0, 15)}...:`), delivery.errorMessage || "Unknown error");
+            });
+        }
+        // Show pending retries
+        const pending = deliveries.filter(d => d.status === "pending" && d.nextRetryAt);
+        if (pending.length > 0) {
+            console.log();
+            console.log(colors.warning("Pending retries:"));
+            pending.forEach(delivery => {
+                console.log(colors.dim(`  ${delivery.id.slice(0, 15)}...:`), `Next retry at ${formatDate(delivery.nextRetryAt)}`);
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deliveries.js","sourceRoot":"","sources":["../../../src/commands/webhooks/deliveries.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EACL,KAAK,EACL,IAAI,EACJ,IAAI,EACJ,MAAM,EACN,UAAU,EACV,UAAU,GACX,MAAM,qBAAqB,CAAC;AAiB7B,MAAM,CAAC,OAAO,OAAO,kBAAmB,SAAQ,oBAAoB;IAClE,MAAM,CAAC,WAAW,GAAG,+BAA+B,CAAC;IAErD,MAAM,CAAC,QAAQ,GAAG;QAChB,kDAAkD;QAClD,6DAA6D;QAC7D,gEAAgE;QAChE,yDAAyD;KAC1D,CAAC;IAEF,MAAM,CAAC,IAAI,GAAG;QACZ,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC;YACd,WAAW,EAAE,YAAY;YACzB,QAAQ,EAAE,IAAI;SACf,CAAC;KACH,CAAC;IAEF,MAAM,CAAC,KAAK,GAAG;QACb,GAAG,oBAAoB,CAAC,SAAS;QACjC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC;YACnB,IAAI,EAAE,GAAG;YACT,WAAW,EAAE,8BAA8B;YAC3C,OAAO,EAAE,EAAE;SACZ,CAAC;QACF,aAAa,EAAE,KAAK,CAAC,OAAO,CAAC;YAC3B,WAAW,EAAE,6BAA6B;YAC1C,OAAO,EAAE,KAAK;SACf,CAAC;KACH,CAAC;IAEF,KAAK,CAAC,GAAG;QACP,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC;QAE7D,MAAM,MAAM,GAAG,IAAI,eAAe,CAAC;YACjC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC;YAC1B,GAAG,CAAC,KAAK,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;SAClD,CAAC,CAAC;QAEH,MAAM,UAAU,GAAG,MAAM,SAAS,CAAC,GAAG,CACpC,oBAAoB,IAAI,CAAC,EAAE,eAAe,MAAM,CAAC,QAAQ,EAAE,EAAE,CAC9D,CAAC;QAEF,IAAI,UAAU,EAAE,EAAE,CAAC;YACjB,IAAI,CAAC,UAAU,CAAC,CAAC;YACjB,OAAO;QACT,CAAC;QAED,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC5B,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,4BAA4B,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC;YAClF,OAAO;QACT,CAAC;QAED,OAAO,CAAC,GAAG,EAAE,CAAC;QACd,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,WAAW,UAAU,CAAC,MAAM,2BAA2B,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;QAC1F,OAAO,CAAC,GAAG,EAAE,CAAC;QAEd,yCAAyC;QACzC,MAAM,sBAAsB,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YAClD,GAAG,CAAC;YACJ,cAAc,EAAE,GAAG,CAAC,CAAC,aAAa,IAAI,CAAC,CAAC,WAAW,EAAE;SACtD,CAAC,CAAC,CAAC;QAEJ,KAAK,CAAC,sBAAsB,EAAE;YAC5B;gBACE,MAAM,EAAE,aAAa;gBACrB,GAAG,EAAE,IAAI;gBACT,KAAK,EAAE,EAAE;gBACT,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,KAAK,CAAC;aAC7D;YACD;gBACE,MAAM,EAAE,OAAO;gBACf,GAAG,EAAE,WAAW;gBAChB,KAAK,EAAE,EAAE;gBACT,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC;aACpD;YACD;gBACE,MAAM,EAAE,QAAQ;gBAChB,GAAG,EAAE,QAAQ;gBACb,KAAK,EAAE,EAAE;gBACT,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE;oBACf,QAAQ,CAAC,EAAE,CAAC;wBACV,KAAK,WAAW;4BACd,OAAO,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;wBACrC,KAAK,QAAQ;4BACX,OAAO,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;wBAChC,KAAK,SAAS;4BACZ,OAAO,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;wBACnC,KAAK,WAAW;4BACd,OAAO,MAAM,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;wBACjC;4BACE,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC;oBACrB,CAAC;gBACH,CAAC;aACF;YACD;gBACE,MAAM,EAAE,SAAS;gBACjB,GAAG,EAAE,gBAAgB;gBACrB,KAAK,EAAE,EAAE;aACV;YACD;gBACE,MAAM,EAAE,aAAa;gBACrB,GAAG,EAAE,oBAAoB;gBACzB,KAAK,EAAE,EAAE;gBACT,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE;oBACf,IAAI,CAAC,CAAC;wBAAE,OAAO,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;oBAC/B,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;oBACvB,OAAO,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,GAAG;wBAC9B,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;wBAC9B,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;gBACjC,CAAC;aACF;YACD;gBACE,MAAM,EAAE,eAAe;gBACvB,GAAG,EAAE,cAAc;gBACnB,KAAK,EAAE,EAAE;gBACT,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC;aACjD;YACD;gBACE,MAAM,EAAE,SAAS;gBACjB,GAAG,EAAE,WAAW;gBAChB,KAAK,EAAE,EAAE;gBACT,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;aACxC;SACF,CAAC,CAAC;QAEH,+BAA+B;QAC/B,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,QAAQ,IAAI,CAAC,CAAC,YAAY,CAAC,CAAC;QAC/E,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE,CAAC;YAC/C,OAAO,CAAC,GAAG,EAAE,CAAC;YACd,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,CAAC;YAChD,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;gBACxB,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,QAAQ,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,YAAY,IAAI,eAAe,CAAC,CAAC;YACzG,CAAC,CAAC,CAAC;QACL,CAAC;QAED,uBAAuB;QACvB,MAAM,OAAO,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,WAAW,CAAC,CAAC;QAChF,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACvB,OAAO,CAAC,GAAG,EAAE,CAAC;YACd,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC;YAChD,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;gBACzB,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,QAAQ,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,iBAAiB,UAAU,CAAC,QAAQ,CAAC,WAAY,CAAC,EAAE,CAAC,CAAC;YACrH,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC","sourcesContent":["import { Args, Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport {\n  table,\n  json,\n  info,\n  colors,\n  formatDate,\n  isJsonMode,\n} from \"../../lib/output.js\";\n\ninterface WebhookDelivery {\n  id: string;\n  eventType: string;\n  attemptNumber: number;\n  maxAttempts: number;\n  status: \"pending\" | \"delivered\" | \"failed\" | \"cancelled\";\n  responseStatusCode?: number;\n  responseTime?: number;\n  errorMessage?: string;\n  errorCode?: string;\n  nextRetryAt?: string;\n  createdAt: string;\n  deliveredAt?: string;\n}\n\nexport default class WebhooksDeliveries extends AuthenticatedCommand {\n  static description = \"View webhook delivery history\";\n\n  static examples = [\n    \"<%= config.bin %> webhooks deliveries whk_abc123\",\n    \"<%= config.bin %> webhooks deliveries whk_abc123 --limit 20\",\n    \"<%= config.bin %> webhooks deliveries whk_abc123 --failed-only\",\n    \"<%= config.bin %> webhooks deliveries whk_abc123 --json\",\n  ];\n\n  static args = {\n    id: Args.string({\n      description: \"Webhook ID\",\n      required: true,\n    }),\n  };\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    limit: Flags.integer({\n      char: \"l\",\n      description: \"Number of deliveries to show\",\n      default: 10,\n    }),\n    \"failed-only\": Flags.boolean({\n      description: \"Show only failed deliveries\",\n      default: false,\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { args, flags } = await this.parse(WebhooksDeliveries);\n\n    const params = new URLSearchParams({\n      limit: String(flags.limit),\n      ...(flags[\"failed-only\"] && { status: \"failed\" }),\n    });\n\n    const deliveries = await apiClient.get<WebhookDelivery[]>(\n      `/api/v1/webhooks/${args.id}/deliveries?${params.toString()}`\n    );\n\n    if (isJsonMode()) {\n      json(deliveries);\n      return;\n    }\n\n    if (deliveries.length === 0) {\n      info(flags[\"failed-only\"] ? \"No failed deliveries found\" : \"No deliveries found\");\n      return;\n    }\n\n    console.log();\n    console.log(colors.dim(`Showing ${deliveries.length} deliveries for webhook ${args.id}`));\n    console.log();\n\n    // Add computed fields for better display\n    const deliveriesWithComputed = deliveries.map(d => ({\n      ...d,\n      attemptDisplay: `${d.attemptNumber}/${d.maxAttempts}`,\n    }));\n\n    table(deliveriesWithComputed, [\n      {\n        header: \"Delivery ID\",\n        key: \"id\",\n        width: 18,\n        formatter: (v) => colors.dim(String(v).slice(0, 15) + \"...\"),\n      },\n      {\n        header: \"Event\",\n        key: \"eventType\",\n        width: 15,\n        formatter: (v) => String(v).replace(\"message.\", \"\"),\n      },\n      {\n        header: \"Status\",\n        key: \"status\",\n        width: 12,\n        formatter: (v) => {\n          switch (v) {\n            case \"delivered\":\n              return colors.success(\"delivered\");\n            case \"failed\":\n              return colors.error(\"failed\");\n            case \"pending\":\n              return colors.warning(\"pending\");\n            case \"cancelled\":\n              return colors.dim(\"cancelled\");\n            default:\n              return String(v);\n          }\n        },\n      },\n      {\n        header: \"Attempt\",\n        key: \"attemptDisplay\",\n        width: 10,\n      },\n      {\n        header: \"Status Code\",\n        key: \"responseStatusCode\",\n        width: 12,\n        formatter: (v) => {\n          if (!v) return colors.dim(\"-\");\n          const code = Number(v);\n          return code >= 200 && code < 300 \n            ? colors.success(String(code))\n            : colors.error(String(code));\n        },\n      },\n      {\n        header: \"Response Time\",\n        key: \"responseTime\",\n        width: 14,\n        formatter: (v) => v ? `${v}ms` : colors.dim(\"-\"),\n      },\n      {\n        header: \"Created\",\n        key: \"createdAt\",\n        width: 16,\n        formatter: (v) => formatDate(String(v)),\n      },\n    ]);\n\n    // Show failed delivery details\n    const failed = deliveries.filter(d => d.status === \"failed\" && d.errorMessage);\n    if (failed.length > 0 && !flags[\"failed-only\"]) {\n      console.log();\n      console.log(colors.error(\"Failed deliveries:\"));\n      failed.forEach(delivery => {\n        console.log(colors.dim(`  ${delivery.id.slice(0, 15)}...:`), delivery.errorMessage || \"Unknown error\");\n      });\n    }\n\n    // Show pending retries\n    const pending = deliveries.filter(d => d.status === \"pending\" && d.nextRetryAt);\n    if (pending.length > 0) {\n      console.log();\n      console.log(colors.warning(\"Pending retries:\"));\n      pending.forEach(delivery => {\n        console.log(colors.dim(`  ${delivery.id.slice(0, 15)}...:`), `Next retry at ${formatDate(delivery.nextRetryAt!)}`);\n      });\n    }\n  }\n}"]}

package/dist/commands/webhooks/get.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class WebhooksGet extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/webhooks/get.js

@@ -0,0 +1,57 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { keyValue, json, header, formatDate, colors, isJsonMode, } from "../../lib/output.js";
+export default class WebhooksGet extends AuthenticatedCommand {
+    static description = "Get webhook details";
+    static examples = [
+        "<%= config.bin %> webhooks get whk_abc123",
+        "<%= config.bin %> webhooks get whk_abc123 --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Webhook ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(WebhooksGet);
+        const webhook = await apiClient.get(`/api/v1/webhooks/${args.id}`);
+        if (isJsonMode()) {
+            json(webhook);
+            return;
+        }
+        header(`Webhook ${webhook.id}`);
+        console.log();
+        keyValue({
+            "ID": webhook.id,
+            "URL": webhook.url,
+            "Events": webhook.events.join(", "),
+            ...(webhook.description ? { "Description": webhook.description } : {}),
+            "Status": webhook.isActive ? colors.success("active") : colors.warning("inactive"),
+            "Circuit State": webhook.circuitState === "closed"
+                ? colors.success("closed")
+                : webhook.circuitState === "open"
+                    ? colors.error("open")
+                    : colors.warning("half_open"),
+            "Failure Count": String(webhook.failureCount),
+            "Secret Version": String(webhook.secretVersion),
+            "Created": formatDate(webhook.createdAt),
+            "Updated": formatDate(webhook.updatedAt),
+        });
+        if (webhook.failureCount > 0) {
+            console.log();
+            console.log(colors.warning(`⚠ This webhook has failed ${webhook.failureCount} times recently.`));
+            console.log(colors.dim("Check delivery history with:"), colors.code(`sendly webhooks deliveries ${webhook.id}`));
+        }
+        if (webhook.circuitState === "open") {
+            console.log();
+            console.log(colors.error("⚠ Circuit breaker is OPEN - webhook deliveries are paused."));
+            console.log(colors.dim("Test your endpoint and the circuit will auto-recover."));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/webhooks/list.js

@@ -11,7 +11,7 @@ export default class WebhooksList extends AuthenticatedCommand {
         ...AuthenticatedCommand.baseFlags,
     };
     async run() {
-        const webhooks = await apiClient.get("/api/webhooks");
+        const webhooks = await apiClient.get("/api/v1/webhooks");
         if (isJsonMode()) {
             json(webhooks);
             return;
@@ -77,4 +77,4 @@ export default class WebhooksList extends AuthenticatedCommand {
         ]);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/webhooks/rotate-secret.d.ts

@@ -0,0 +1,14 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class WebhooksRotateSecret extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        yes: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/webhooks/rotate-secret.js

@@ -0,0 +1,87 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, warn, error, json, colors, codeBlock, isJsonMode, } from "../../lib/output.js";
+import inquirer from "inquirer";
+export default class WebhooksRotateSecret extends AuthenticatedCommand {
+    static description = "Rotate webhook secret";
+    static examples = [
+        "<%= config.bin %> webhooks rotate-secret whk_abc123",
+        "<%= config.bin %> webhooks rotate-secret whk_abc123 --yes",
+        "<%= config.bin %> webhooks rotate-secret whk_abc123 --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Webhook ID",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        yes: Flags.boolean({
+            char: "y",
+            description: "Skip confirmation prompt",
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WebhooksRotateSecret);
+        // Get webhook details for confirmation
+        let webhook;
+        try {
+            webhook = await apiClient.get(`/api/v1/webhooks/${args.id}`);
+        }
+        catch (err) {
+            error(`Webhook not found: ${args.id}`);
+            this.exit(1);
+        }
+        // Confirm rotation
+        if (!flags.yes && !isJsonMode()) {
+            console.log();
+            console.log(colors.warning("⚠ This will rotate the webhook secret and invalidate the old one after 24 hours."));
+            console.log(colors.dim("Make sure to update your application with the new secret."));
+            console.log();
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Rotate secret for webhook ${colors.code(args.id)} (${colors.dim(webhook.url)})?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                error("Secret rotation cancelled");
+                return;
+            }
+        }
+        try {
+            const result = await apiClient.post(`/api/v1/webhooks/${args.id}/rotate-secret`);
+            if (isJsonMode()) {
+                json(result);
+                return;
+            }
+            success("Webhook secret rotated", {
+                "Webhook ID": result.id,
+                "Secret Version": `${webhook.secretVersion} → ${result.newSecretVersion}`,
+                "Grace Period": `${result.gracePeriodHours} hours`,
+                "Rotated At": result.rotatedAt,
+            });
+            console.log();
+            warn("Copy your new webhook secret now. The old secret will expire in 24 hours!");
+            codeBlock(result.newSecret);
+            console.log();
+            console.log(colors.dim("Update your application with this new secret for webhook signature verification."));
+            console.log(colors.dim(`The old secret will remain valid for ${result.gracePeriodHours} hours to allow for graceful migration.`));
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                error(`Failed to rotate secret: ${err.message}`);
+            }
+            else {
+                error(`Failed to rotate secret: ${String(err)}`);
+            }
+            this.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rotate-secret.js","sourceRoot":"","sources":["../../../src/commands/webhooks/rotate-secret.ts"],"names":[],"mappings":"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","sourcesContent":["import { Args, Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport {\n  success,\n  warn,\n  error,\n  json,\n  colors,\n  codeBlock,\n  isJsonMode,\n} from \"../../lib/output.js\";\nimport inquirer from \"inquirer\";\n\ninterface RotateSecretResponse {\n  id: string;\n  newSecret: string;\n  newSecretVersion: number;\n  gracePeriodHours: number;\n  rotatedAt: string;\n}\n\nexport default class WebhooksRotateSecret extends AuthenticatedCommand {\n  static description = \"Rotate webhook secret\";\n\n  static examples = [\n    \"<%= config.bin %> webhooks rotate-secret whk_abc123\",\n    \"<%= config.bin %> webhooks rotate-secret whk_abc123 --yes\",\n    \"<%= config.bin %> webhooks rotate-secret whk_abc123 --json\",\n  ];\n\n  static args = {\n    id: Args.string({\n      description: \"Webhook ID\",\n      required: true,\n    }),\n  };\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    yes: Flags.boolean({\n      char: \"y\",\n      description: \"Skip confirmation prompt\",\n      default: false,\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { args, flags } = await this.parse(WebhooksRotateSecret);\n\n    // Get webhook details for confirmation\n    let webhook;\n    try {\n      webhook = await apiClient.get<{ id: string; url: string; secretVersion: number }>(\n        `/api/v1/webhooks/${args.id}`\n      );\n    } catch (err) {\n      error(`Webhook not found: ${args.id}`);\n      this.exit(1);\n    }\n\n    // Confirm rotation\n    if (!flags.yes && !isJsonMode()) {\n      console.log();\n      console.log(colors.warning(\"⚠ This will rotate the webhook secret and invalidate the old one after 24 hours.\"));\n      console.log(colors.dim(\"Make sure to update your application with the new secret.\"));\n      console.log();\n\n      const { confirm } = await inquirer.prompt([\n        {\n          type: \"confirm\",\n          name: \"confirm\",\n          message: `Rotate secret for webhook ${colors.code(args.id)} (${colors.dim(webhook.url)})?`,\n          default: false,\n        },\n      ]);\n\n      if (!confirm) {\n        error(\"Secret rotation cancelled\");\n        return;\n      }\n    }\n\n    try {\n      const result = await apiClient.post<RotateSecretResponse>(\n        `/api/v1/webhooks/${args.id}/rotate-secret`\n      );\n\n      if (isJsonMode()) {\n        json(result);\n        return;\n      }\n\n      success(\"Webhook secret rotated\", {\n        \"Webhook ID\": result.id,\n        \"Secret Version\": `${webhook.secretVersion} → ${result.newSecretVersion}`,\n        \"Grace Period\": `${result.gracePeriodHours} hours`,\n        \"Rotated At\": result.rotatedAt,\n      });\n\n      console.log();\n      warn(\"Copy your new webhook secret now. The old secret will expire in 24 hours!\");\n      codeBlock(result.newSecret);\n\n      console.log();\n      console.log(colors.dim(\"Update your application with this new secret for webhook signature verification.\"));\n      console.log(colors.dim(`The old secret will remain valid for ${result.gracePeriodHours} hours to allow for graceful migration.`));\n\n    } catch (err) {\n      if (err instanceof Error) {\n        error(`Failed to rotate secret: ${err.message}`);\n      } else {\n        error(`Failed to rotate secret: ${String(err)}`);\n      }\n      this.exit(1);\n    }\n  }\n}"]}

package/dist/commands/webhooks/test.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class WebhooksTest extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/webhooks/test.js

@@ -0,0 +1,73 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, error, spinner, json, colors, isJsonMode, } from "../../lib/output.js";
+export default class WebhooksTest extends AuthenticatedCommand {
+    static description = "Send a test event to a webhook";
+    static examples = [
+        "<%= config.bin %> webhooks test whk_abc123",
+        "<%= config.bin %> webhooks test whk_abc123 --json",
+    ];
+    static args = {
+        id: Args.string({
+            description: "Webhook ID to test",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(WebhooksTest);
+        const testSpinner = spinner("Sending test event...");
+        testSpinner.start();
+        try {
+            const result = await apiClient.post(`/api/v1/webhooks/${args.id}/test`);
+            testSpinner.stop();
+            if (isJsonMode()) {
+                json(result);
+                return;
+            }
+            if (result.status === "delivered") {
+                success("Test event delivered", {
+                    "Delivery ID": result.deliveryId,
+                    "Webhook URL": result.webhookUrl,
+                    "Event Type": result.eventType,
+                    "Response Time": `${result.responseTime}ms`,
+                    "Status Code": String(result.statusCode),
+                    "Delivered At": result.deliveredAt,
+                });
+                if (result.responseBody) {
+                    console.log();
+                    console.log(colors.dim("Response Body:"));
+                    console.log(result.responseBody.substring(0, 200) + (result.responseBody.length > 200 ? "..." : ""));
+                }
+            }
+            else {
+                error("Test event failed", {
+                    "Delivery ID": result.deliveryId,
+                    "Webhook URL": result.webhookUrl,
+                    "Status": result.status,
+                    "Error": result.error || "Unknown error",
+                    ...(result.statusCode && { "Status Code": String(result.statusCode) }),
+                });
+            }
+        }
+        catch (err) {
+            testSpinner.stop();
+            if (err instanceof Error && err.message.includes("404")) {
+                error(`Webhook not found: ${args.id}`);
+            }
+            else {
+                if (err instanceof Error) {
+                    error(`Failed to send test event: ${err.message}`);
+                }
+                else {
+                    error(`Failed to send test event: ${String(err)}`);
+                }
+            }
+            this.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/webhooks/update.d.ts

@@ -0,0 +1,17 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class WebhooksUpdate extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        url: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        events: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        active: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/webhooks/update.js

@@ -0,0 +1,104 @@
+import { Args, Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, error, json, colors, isJsonMode, } from "../../lib/output.js";
+export default class WebhooksUpdate extends AuthenticatedCommand {
+    static description = "Update a webhook";
+    static examples = [
+        '<%= config.bin %> webhooks update whk_abc123 --url https://newdomain.com/webhook',
+        '<%= config.bin %> webhooks update whk_abc123 --events message.delivered,message.failed',
+        '<%= config.bin %> webhooks update whk_abc123 --description "Updated production webhook"',
+        '<%= config.bin %> webhooks update whk_abc123 --active false',
+        '<%= config.bin %> webhooks update whk_abc123 --url https://newdomain.com/webhook --events message.sent --json',
+    ];
+    static args = {
+        id: Args.string({
+            description: "Webhook ID to update",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        url: Flags.string({
+            char: "u",
+            description: "Update webhook URL (must be HTTPS)",
+        }),
+        events: Flags.string({
+            char: "e",
+            description: "Update events list (comma-separated)",
+        }),
+        description: Flags.string({
+            char: "d",
+            description: "Update description",
+        }),
+        active: Flags.boolean({
+            char: "a",
+            description: "Enable or disable the webhook",
+            allowNo: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WebhooksUpdate);
+        // Check if any update flags were provided
+        const hasUpdates = !!(flags.url || flags.events || flags.description || flags.active !== undefined);
+        if (!hasUpdates) {
+            error("No updates specified. Use --url, --events, --description, or --active flags.");
+            this.exit(1);
+        }
+        // Build update payload
+        const updateData = {};
+        if (flags.url) {
+            updateData.url = flags.url;
+        }
+        if (flags.events) {
+            updateData.events = flags.events.split(",").map(e => e.trim());
+        }
+        if (flags.description !== undefined) {
+            updateData.description = flags.description;
+        }
+        if (flags.active !== undefined) {
+            updateData.isActive = flags.active;
+        }
+        try {
+            const webhook = await apiClient.patch(`/api/v1/webhooks/${args.id}`, updateData);
+            if (isJsonMode()) {
+                json(webhook);
+                return;
+            }
+            success("Webhook updated", {
+                ID: webhook.id,
+                URL: webhook.url,
+                Events: webhook.events.join(", "),
+                ...(webhook.description && { Description: webhook.description }),
+                Status: webhook.isActive ? colors.success("active") : colors.warning("inactive"),
+                "Updated At": webhook.updatedAt,
+            });
+            // Show what changed
+            console.log();
+            console.log(colors.dim("Updated fields:"));
+            if (flags.url)
+                console.log(colors.dim("  • URL"));
+            if (flags.events)
+                console.log(colors.dim("  • Events"));
+            if (flags.description !== undefined)
+                console.log(colors.dim("  • Description"));
+            if (flags.active !== undefined)
+                console.log(colors.dim("  • Active status"));
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("404")) {
+                error(`Webhook not found: ${args.id}`);
+            }
+            else {
+                if (err instanceof Error) {
+                    error(`Failed to update webhook: ${err.message}`);
+                }
+                else {
+                    error(`Failed to update webhook: ${String(err)}`);
+                }
+            }
+            this.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"update.js","sourceRoot":"","sources":["../../../src/commands/webhooks/update.ts"],"names":[],"mappings":"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","sourcesContent":["import { Args, Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport {\n  success,\n  error,\n  json,\n  colors,\n  isJsonMode,\n} from \"../../lib/output.js\";\n\ninterface UpdateWebhookResponse {\n  id: string;\n  url: string;\n  events: string[];\n  description?: string;\n  isActive: boolean;\n  updatedAt: string;\n}\n\nexport default class WebhooksUpdate extends AuthenticatedCommand {\n  static description = \"Update a webhook\";\n\n  static examples = [\n    '<%= config.bin %> webhooks update whk_abc123 --url https://newdomain.com/webhook',\n    '<%= config.bin %> webhooks update whk_abc123 --events message.delivered,message.failed',\n    '<%= config.bin %> webhooks update whk_abc123 --description \"Updated production webhook\"',\n    '<%= config.bin %> webhooks update whk_abc123 --active false',\n    '<%= config.bin %> webhooks update whk_abc123 --url https://newdomain.com/webhook --events message.sent --json',\n  ];\n\n  static args = {\n    id: Args.string({\n      description: \"Webhook ID to update\",\n      required: true,\n    }),\n  };\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    url: Flags.string({\n      char: \"u\",\n      description: \"Update webhook URL (must be HTTPS)\",\n    }),\n    events: Flags.string({\n      char: \"e\",\n      description: \"Update events list (comma-separated)\",\n    }),\n    description: Flags.string({\n      char: \"d\",\n      description: \"Update description\",\n    }),\n    active: Flags.boolean({\n      char: \"a\",\n      description: \"Enable or disable the webhook\",\n      allowNo: true,\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { args, flags } = await this.parse(WebhooksUpdate);\n\n    // Check if any update flags were provided\n    const hasUpdates = !!(flags.url || flags.events || flags.description || flags.active !== undefined);\n    \n    if (!hasUpdates) {\n      error(\"No updates specified. Use --url, --events, --description, or --active flags.\");\n      this.exit(1);\n    }\n\n    // Build update payload\n    const updateData: any = {};\n    \n    if (flags.url) {\n      updateData.url = flags.url;\n    }\n    \n    if (flags.events) {\n      updateData.events = flags.events.split(\",\").map(e => e.trim());\n    }\n    \n    if (flags.description !== undefined) {\n      updateData.description = flags.description;\n    }\n    \n    if (flags.active !== undefined) {\n      updateData.isActive = flags.active;\n    }\n\n    try {\n      const webhook = await apiClient.patch<UpdateWebhookResponse>(\n        `/api/v1/webhooks/${args.id}`,\n        updateData\n      );\n\n      if (isJsonMode()) {\n        json(webhook);\n        return;\n      }\n\n      success(\"Webhook updated\", {\n        ID: webhook.id,\n        URL: webhook.url,\n        Events: webhook.events.join(\", \"),\n        ...(webhook.description && { Description: webhook.description }),\n        Status: webhook.isActive ? colors.success(\"active\") : colors.warning(\"inactive\"),\n        \"Updated At\": webhook.updatedAt,\n      });\n\n      // Show what changed\n      console.log();\n      console.log(colors.dim(\"Updated fields:\"));\n      if (flags.url) console.log(colors.dim(\"  • URL\"));\n      if (flags.events) console.log(colors.dim(\"  • Events\"));\n      if (flags.description !== undefined) console.log(colors.dim(\"  • Description\"));\n      if (flags.active !== undefined) console.log(colors.dim(\"  • Active status\"));\n\n    } catch (err) {\n      if (err instanceof Error && err.message.includes(\"404\")) {\n        error(`Webhook not found: ${args.id}`);\n      } else {\n        if (err instanceof Error) {\n          error(`Failed to update webhook: ${err.message}`);\n        } else {\n          error(`Failed to update webhook: ${String(err)}`);\n        }\n      }\n      this.exit(1);\n    }\n  }\n}"]}

package/oclif.manifest.json

@@ -1039,6 +1039,228 @@
         "send.js"
       ]
     },
+    "webhooks:create": {
+      "aliases": [],
+      "args": {},
+      "description": "Create a webhook",
+      "examples": [
+        "<%= config.bin %> webhooks create --url https://myapp.com/webhook --events message.delivered",
+        "<%= config.bin %> webhooks create --url https://myapp.com/webhook --events message.delivered,message.failed --description \"Production webhook\"",
+        "<%= config.bin %> webhooks create --url https://webhook.site/abc123 --events message.sent --json"
+      ],
+      "flags": {
+        "json": {
+          "description": "Output in JSON format",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "quiet": {
+          "char": "q",
+          "description": "Minimal output",
+          "name": "quiet",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "url": {
+          "char": "u",
+          "description": "Webhook URL (must be HTTPS)",
+          "name": "url",
+          "required": true,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "events": {
+          "char": "e",
+          "description": "Comma-separated list of events to listen for",
+          "name": "events",
+          "required": true,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "description": {
+          "char": "d",
+          "description": "Description for the webhook",
+          "name": "description",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "webhooks:create",
+      "pluginAlias": "@sendly/cli",
+      "pluginName": "@sendly/cli",
+      "pluginType": "core",
+      "strict": true,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "webhooks",
+        "create.js"
+      ]
+    },
+    "webhooks:delete": {
+      "aliases": [],
+      "args": {
+        "id": {
+          "description": "Webhook ID to delete",
+          "name": "id",
+          "required": true
+        }
+      },
+      "description": "Delete a webhook",
+      "examples": [
+        "<%= config.bin %> webhooks delete whk_abc123",
+        "<%= config.bin %> webhooks delete whk_abc123 --yes",
+        "<%= config.bin %> webhooks delete whk_abc123 --json"
+      ],
+      "flags": {
+        "json": {
+          "description": "Output in JSON format",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "quiet": {
+          "char": "q",
+          "description": "Minimal output",
+          "name": "quiet",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "yes": {
+          "char": "y",
+          "description": "Skip confirmation prompt",
+          "name": "yes",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "webhooks:delete",
+      "pluginAlias": "@sendly/cli",
+      "pluginName": "@sendly/cli",
+      "pluginType": "core",
+      "strict": true,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "webhooks",
+        "delete.js"
+      ]
+    },
+    "webhooks:deliveries": {
+      "aliases": [],
+      "args": {
+        "id": {
+          "description": "Webhook ID",
+          "name": "id",
+          "required": true
+        }
+      },
+      "description": "View webhook delivery history",
+      "examples": [
+        "<%= config.bin %> webhooks deliveries whk_abc123",
+        "<%= config.bin %> webhooks deliveries whk_abc123 --limit 20",
+        "<%= config.bin %> webhooks deliveries whk_abc123 --failed-only",
+        "<%= config.bin %> webhooks deliveries whk_abc123 --json"
+      ],
+      "flags": {
+        "json": {
+          "description": "Output in JSON format",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "quiet": {
+          "char": "q",
+          "description": "Minimal output",
+          "name": "quiet",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "limit": {
+          "char": "l",
+          "description": "Number of deliveries to show",
+          "name": "limit",
+          "default": 10,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "failed-only": {
+          "description": "Show only failed deliveries",
+          "name": "failed-only",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "webhooks:deliveries",
+      "pluginAlias": "@sendly/cli",
+      "pluginName": "@sendly/cli",
+      "pluginType": "core",
+      "strict": true,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "webhooks",
+        "deliveries.js"
+      ]
+    },
+    "webhooks:get": {
+      "aliases": [],
+      "args": {
+        "id": {
+          "description": "Webhook ID",
+          "name": "id",
+          "required": true
+        }
+      },
+      "description": "Get webhook details",
+      "examples": [
+        "<%= config.bin %> webhooks get whk_abc123",
+        "<%= config.bin %> webhooks get whk_abc123 --json"
+      ],
+      "flags": {
+        "json": {
+          "description": "Output in JSON format",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "quiet": {
+          "char": "q",
+          "description": "Minimal output",
+          "name": "quiet",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "webhooks:get",
+      "pluginAlias": "@sendly/cli",
+      "pluginName": "@sendly/cli",
+      "pluginType": "core",
+      "strict": true,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "webhooks",
+        "get.js"
+      ]
+    },
     "webhooks:list": {
       "aliases": [],
       "args": {},
@@ -1141,7 +1363,181 @@
         "webhooks",
         "listen.js"
       ]
+    },
+    "webhooks:rotate-secret": {
+      "aliases": [],
+      "args": {
+        "id": {
+          "description": "Webhook ID",
+          "name": "id",
+          "required": true
+        }
+      },
+      "description": "Rotate webhook secret",
+      "examples": [
+        "<%= config.bin %> webhooks rotate-secret whk_abc123",
+        "<%= config.bin %> webhooks rotate-secret whk_abc123 --yes",
+        "<%= config.bin %> webhooks rotate-secret whk_abc123 --json"
+      ],
+      "flags": {
+        "json": {
+          "description": "Output in JSON format",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "quiet": {
+          "char": "q",
+          "description": "Minimal output",
+          "name": "quiet",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "yes": {
+          "char": "y",
+          "description": "Skip confirmation prompt",
+          "name": "yes",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "webhooks:rotate-secret",
+      "pluginAlias": "@sendly/cli",
+      "pluginName": "@sendly/cli",
+      "pluginType": "core",
+      "strict": true,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "webhooks",
+        "rotate-secret.js"
+      ]
+    },
+    "webhooks:test": {
+      "aliases": [],
+      "args": {
+        "id": {
+          "description": "Webhook ID to test",
+          "name": "id",
+          "required": true
+        }
+      },
+      "description": "Send a test event to a webhook",
+      "examples": [
+        "<%= config.bin %> webhooks test whk_abc123",
+        "<%= config.bin %> webhooks test whk_abc123 --json"
+      ],
+      "flags": {
+        "json": {
+          "description": "Output in JSON format",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "quiet": {
+          "char": "q",
+          "description": "Minimal output",
+          "name": "quiet",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "webhooks:test",
+      "pluginAlias": "@sendly/cli",
+      "pluginName": "@sendly/cli",
+      "pluginType": "core",
+      "strict": true,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "webhooks",
+        "test.js"
+      ]
+    },
+    "webhooks:update": {
+      "aliases": [],
+      "args": {
+        "id": {
+          "description": "Webhook ID to update",
+          "name": "id",
+          "required": true
+        }
+      },
+      "description": "Update a webhook",
+      "examples": [
+        "<%= config.bin %> webhooks update whk_abc123 --url https://newdomain.com/webhook",
+        "<%= config.bin %> webhooks update whk_abc123 --events message.delivered,message.failed",
+        "<%= config.bin %> webhooks update whk_abc123 --description \"Updated production webhook\"",
+        "<%= config.bin %> webhooks update whk_abc123 --active false",
+        "<%= config.bin %> webhooks update whk_abc123 --url https://newdomain.com/webhook --events message.sent --json"
+      ],
+      "flags": {
+        "json": {
+          "description": "Output in JSON format",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "quiet": {
+          "char": "q",
+          "description": "Minimal output",
+          "name": "quiet",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "url": {
+          "char": "u",
+          "description": "Update webhook URL (must be HTTPS)",
+          "name": "url",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "events": {
+          "char": "e",
+          "description": "Update events list (comma-separated)",
+          "name": "events",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "description": {
+          "char": "d",
+          "description": "Update description",
+          "name": "description",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "active": {
+          "char": "a",
+          "description": "Enable or disable the webhook",
+          "name": "active",
+          "allowNo": true,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "webhooks:update",
+      "pluginAlias": "@sendly/cli",
+      "pluginName": "@sendly/cli",
+      "pluginType": "core",
+      "strict": true,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "webhooks",
+        "update.js"
+      ]
     }
   },
-  "version": "2.2.0"
+  "version": "2.3.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sendly/cli",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "type": "module",
   "description": "Sendly CLI - Send SMS from your terminal",
   "author": "Sendly <support@sendly.live>",