@sendly/cli 1.0.0

package/dist/commands/sms/scheduled.js

@@ -0,0 +1,82 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { table, json, info, formatStatus, formatPhone, colors, isJsonMode, } from "../../lib/output.js";
+export default class SmsScheduled extends AuthenticatedCommand {
+    static description = "List scheduled messages";
+    static examples = [
+        "<%= config.bin %> sms scheduled",
+        "<%= config.bin %> sms scheduled --limit 10",
+        "<%= config.bin %> sms scheduled --status scheduled",
+        "<%= config.bin %> sms scheduled --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        limit: Flags.integer({
+            char: "l",
+            description: "Number of messages to show",
+            default: 20,
+        }),
+        status: Flags.string({
+            char: "s",
+            description: "Filter by status (scheduled, sent, cancelled, failed)",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SmsScheduled);
+        const response = await apiClient.get("/api/v1/messages/scheduled", {
+            limit: flags.limit,
+            ...(flags.status && { status: flags.status }),
+        });
+        if (isJsonMode()) {
+            json(response);
+            return;
+        }
+        if (response.data.length === 0) {
+            info("No scheduled messages found");
+            return;
+        }
+        console.log();
+        console.log(colors.dim(`Showing ${response.data.length} of ${response.count} scheduled messages`));
+        console.log();
+        table(response.data, [
+            {
+                header: "ID",
+                key: "id",
+                width: 20,
+                formatter: (v) => colors.dim(String(v).slice(0, 16) + "..."),
+            },
+            {
+                header: "To",
+                key: "to",
+                width: 18,
+                formatter: (v) => formatPhone(String(v)),
+            },
+            {
+                header: "Status",
+                key: "status",
+                width: 12,
+                formatter: (v) => formatStatus(String(v)),
+            },
+            {
+                header: "Scheduled For",
+                key: "scheduledAt",
+                width: 20,
+                formatter: (v) => {
+                    const date = new Date(String(v));
+                    return colors.code(date.toLocaleString());
+                },
+            },
+            {
+                header: "Text",
+                key: "text",
+                width: 25,
+                formatter: (v) => {
+                    const text = String(v);
+                    return text.length > 22 ? text.slice(0, 22) + "..." : text;
+                },
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZWR1bGVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbW1hbmRzL3Ntcy9zY2hlZHVsZWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUNwQyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUNqRSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDcEQsT0FBTyxFQUNMLEtBQUssRUFDTCxJQUFJLEVBQ0osSUFBSSxFQUNKLFlBQVksRUFDWixXQUFXLEVBQ1gsTUFBTSxFQUNOLFVBQVUsR0FDWCxNQUFNLHFCQUFxQixDQUFDO0FBaUI3QixNQUFNLENBQUMsT0FBTyxPQUFPLFlBQWEsU0FBUSxvQkFBb0I7SUFDNUQsTUFBTSxDQUFDLFdBQVcsR0FBRyx5QkFBeUIsQ0FBQztJQUUvQyxNQUFNLENBQUMsUUFBUSxHQUFHO1FBQ2hCLGlDQUFpQztRQUNqQyw0Q0FBNEM7UUFDNUMsb0RBQW9EO1FBQ3BELHdDQUF3QztLQUN6QyxDQUFDO0lBRUYsTUFBTSxDQUFDLEtBQUssR0FBRztRQUNiLEdBQUcsb0JBQW9CLENBQUMsU0FBUztRQUNqQyxLQUFLLEVBQUUsS0FBSyxDQUFDLE9BQU8sQ0FBQztZQUNuQixJQUFJLEVBQUUsR0FBRztZQUNULFdBQVcsRUFBRSw0QkFBNEI7WUFDekMsT0FBTyxFQUFFLEVBQUU7U0FDWixDQUFDO1FBQ0YsTUFBTSxFQUFFLEtBQUssQ0FBQyxNQUFNLENBQUM7WUFDbkIsSUFBSSxFQUFFLEdBQUc7WUFDVCxXQUFXLEVBQUUsdURBQXVEO1NBQ3JFLENBQUM7S0FDSCxDQUFDO0lBRUYsS0FBSyxDQUFDLEdBQUc7UUFDUCxNQUFNLEVBQUUsS0FBSyxFQUFFLEdBQUcsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBRWpELE1BQU0sUUFBUSxHQUFHLE1BQU0sU0FBUyxDQUFDLEdBQUcsQ0FDbEMsNEJBQTRCLEVBQzVCO1lBQ0UsS0FBSyxFQUFFLEtBQUssQ0FBQyxLQUFLO1lBQ2xCLEdBQUcsQ0FBQyxLQUFLLENBQUMsTUFBTSxJQUFJLEVBQUUsTUFBTSxFQUFFLEtBQUssQ0FBQyxNQUFNLEVBQUUsQ0FBQztTQUM5QyxDQUNGLENBQUM7UUFFRixJQUFJLFVBQVUsRUFBRSxFQUFFLENBQUM7WUFDakIsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1lBQ2YsT0FBTztRQUNULENBQUM7UUFFRCxJQUFJLFFBQVEsQ0FBQyxJQUFJLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1lBQy9CLElBQUksQ0FBQyw2QkFBNkIsQ0FBQyxDQUFDO1lBQ3BDLE9BQU87UUFDVCxDQUFDO1FBRUQsT0FBTyxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBQ2QsT0FBTyxDQUFDLEdBQUcsQ0FDVCxNQUFNLENBQUMsR0FBRyxDQUNSLFdBQVcsUUFBUSxDQUFDLElBQUksQ0FBQyxNQUFNLE9BQU8sUUFBUSxDQUFDLEtBQUsscUJBQXFCLENBQzFFLENBQ0YsQ0FBQztRQUNGLE9BQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUVkLEtBQUssQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFO1lBQ25CO2dCQUNFLE1BQU0sRUFBRSxJQUFJO2dCQUNaLEdBQUcsRUFBRSxJQUFJO2dCQUNULEtBQUssRUFBRSxFQUFFO2dCQUNULFNBQVMsRUFBRSxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsR0FBRyxLQUFLLENBQUM7YUFDN0Q7WUFDRDtnQkFDRSxNQUFNLEVBQUUsSUFBSTtnQkFDWixHQUFHLEVBQUUsSUFBSTtnQkFDVCxLQUFLLEVBQUUsRUFBRTtnQkFDVCxTQUFTLEVBQUUsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUM7YUFDekM7WUFDRDtnQkFDRSxNQUFNLEVBQUUsUUFBUTtnQkFDaEIsR0FBRyxFQUFFLFFBQVE7Z0JBQ2IsS0FBSyxFQUFFLEVBQUU7Z0JBQ1QsU0FBUyxFQUFFLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxZQUFZLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDO2FBQzFDO1lBQ0Q7Z0JBQ0UsTUFBTSxFQUFFLGVBQWU7Z0JBQ3ZCLEdBQUcsRUFBRSxhQUFhO2dCQUNsQixLQUFLLEVBQUUsRUFBRTtnQkFDVCxTQUFTLEVBQUUsQ0FBQyxDQUFDLEVBQUUsRUFBRTtvQkFDZixNQUFNLElBQUksR0FBRyxJQUFJLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztvQkFDakMsT0FBTyxNQUFNLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxjQUFjLEVBQUUsQ0FBQyxDQUFDO2dCQUM1QyxDQUFDO2FBQ0Y7WUFDRDtnQkFDRSxNQUFNLEVBQUUsTUFBTTtnQkFDZCxHQUFHLEVBQUUsTUFBTTtnQkFDWCxLQUFLLEVBQUUsRUFBRTtnQkFDVCxTQUFTLEVBQUUsQ0FBQyxDQUFDLEVBQUUsRUFBRTtvQkFDZixNQUFNLElBQUksR0FBRyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUM7b0JBQ3ZCLE9BQU8sSUFBSSxDQUFDLE1BQU0sR0FBRyxFQUFFLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxHQUFHLEtBQUssQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDO2dCQUM3RCxDQUFDO2FBQ0Y7U0FDRixDQUFDLENBQUM7SUFDTCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRmxhZ3MgfSBmcm9tIFwiQG9jbGlmL2NvcmVcIjtcbmltcG9ydCB7IEF1dGhlbnRpY2F0ZWRDb21tYW5kIH0gZnJvbSBcIi4uLy4uL2xpYi9iYXNlLWNvbW1hbmQuanNcIjtcbmltcG9ydCB7IGFwaUNsaWVudCB9IGZyb20gXCIuLi8uLi9saWIvYXBpLWNsaWVudC5qc1wiO1xuaW1wb3J0IHtcbiAgdGFibGUsXG4gIGpzb24sXG4gIGluZm8sXG4gIGZvcm1hdFN0YXR1cyxcbiAgZm9ybWF0UGhvbmUsXG4gIGNvbG9ycyxcbiAgaXNKc29uTW9kZSxcbn0gZnJvbSBcIi4uLy4uL2xpYi9vdXRwdXQuanNcIjtcblxuaW50ZXJmYWNlIFNjaGVkdWxlZE1lc3NhZ2Uge1xuICBpZDogc3RyaW5nO1xuICB0bzogc3RyaW5nO1xuICBmcm9tPzogc3RyaW5nO1xuICB0ZXh0OiBzdHJpbmc7XG4gIHN0YXR1czogc3RyaW5nO1xuICBzY2hlZHVsZWRBdDogc3RyaW5nO1xuICBjcmVhdGVkQXQ6IHN0cmluZztcbn1cblxuaW50ZXJmYWNlIExpc3RTY2hlZHVsZWRSZXNwb25zZSB7XG4gIGRhdGE6IFNjaGVkdWxlZE1lc3NhZ2VbXTtcbiAgY291bnQ6IG51bWJlcjtcbn1cblxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgU21zU2NoZWR1bGVkIGV4dGVuZHMgQXV0aGVudGljYXRlZENvbW1hbmQge1xuICBzdGF0aWMgZGVzY3JpcHRpb24gPSBcIkxpc3Qgc2NoZWR1bGVkIG1lc3NhZ2VzXCI7XG5cbiAgc3RhdGljIGV4YW1wbGVzID0gW1xuICAgIFwiPCU9IGNvbmZpZy5iaW4gJT4gc21zIHNjaGVkdWxlZFwiLFxuICAgIFwiPCU9IGNvbmZpZy5iaW4gJT4gc21zIHNjaGVkdWxlZCAtLWxpbWl0IDEwXCIsXG4gICAgXCI8JT0gY29uZmlnLmJpbiAlPiBzbXMgc2NoZWR1bGVkIC0tc3RhdHVzIHNjaGVkdWxlZFwiLFxuICAgIFwiPCU9IGNvbmZpZy5iaW4gJT4gc21zIHNjaGVkdWxlZCAtLWpzb25cIixcbiAgXTtcblxuICBzdGF0aWMgZmxhZ3MgPSB7XG4gICAgLi4uQXV0aGVudGljYXRlZENvbW1hbmQuYmFzZUZsYWdzLFxuICAgIGxpbWl0OiBGbGFncy5pbnRlZ2VyKHtcbiAgICAgIGNoYXI6IFwibFwiLFxuICAgICAgZGVzY3JpcHRpb246IFwiTnVtYmVyIG9mIG1lc3NhZ2VzIHRvIHNob3dcIixcbiAgICAgIGRlZmF1bHQ6IDIwLFxuICAgIH0pLFxuICAgIHN0YXR1czogRmxhZ3Muc3RyaW5nKHtcbiAgICAgIGNoYXI6IFwic1wiLFxuICAgICAgZGVzY3JpcHRpb246IFwiRmlsdGVyIGJ5IHN0YXR1cyAoc2NoZWR1bGVkLCBzZW50LCBjYW5jZWxsZWQsIGZhaWxlZClcIixcbiAgICB9KSxcbiAgfTtcblxuICBhc3luYyBydW4oKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgY29uc3QgeyBmbGFncyB9ID0gYXdhaXQgdGhpcy5wYXJzZShTbXNTY2hlZHVsZWQpO1xuXG4gICAgY29uc3QgcmVzcG9uc2UgPSBhd2FpdCBhcGlDbGllbnQuZ2V0PExpc3RTY2hlZHVsZWRSZXNwb25zZT4oXG4gICAgICBcIi9hcGkvdjEvbWVzc2FnZXMvc2NoZWR1bGVkXCIsXG4gICAgICB7XG4gICAgICAgIGxpbWl0OiBmbGFncy5saW1pdCxcbiAgICAgICAgLi4uKGZsYWdzLnN0YXR1cyAmJiB7IHN0YXR1czogZmxhZ3Muc3RhdHVzIH0pLFxuICAgICAgfSxcbiAgICApO1xuXG4gICAgaWYgKGlzSnNvbk1vZGUoKSkge1xuICAgICAganNvbihyZXNwb25zZSk7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgaWYgKHJlc3BvbnNlLmRhdGEubGVuZ3RoID09PSAwKSB7XG4gICAgICBpbmZvKFwiTm8gc2NoZWR1bGVkIG1lc3NhZ2VzIGZvdW5kXCIpO1xuICAgICAgcmV0dXJuO1xuICAgIH1cblxuICAgIGNvbnNvbGUubG9nKCk7XG4gICAgY29uc29sZS5sb2coXG4gICAgICBjb2xvcnMuZGltKFxuICAgICAgICBgU2hvd2luZyAke3Jlc3BvbnNlLmRhdGEubGVuZ3RofSBvZiAke3Jlc3BvbnNlLmNvdW50fSBzY2hlZHVsZWQgbWVzc2FnZXNgLFxuICAgICAgKSxcbiAgICApO1xuICAgIGNvbnNvbGUubG9nKCk7XG5cbiAgICB0YWJsZShyZXNwb25zZS5kYXRhLCBbXG4gICAgICB7XG4gICAgICAgIGhlYWRlcjogXCJJRFwiLFxuICAgICAgICBrZXk6IFwiaWRcIixcbiAgICAgICAgd2lkdGg6IDIwLFxuICAgICAgICBmb3JtYXR0ZXI6ICh2KSA9PiBjb2xvcnMuZGltKFN0cmluZyh2KS5zbGljZSgwLCAxNikgKyBcIi4uLlwiKSxcbiAgICAgIH0sXG4gICAgICB7XG4gICAgICAgIGhlYWRlcjogXCJUb1wiLFxuICAgICAgICBrZXk6IFwidG9cIixcbiAgICAgICAgd2lkdGg6IDE4LFxuICAgICAgICBmb3JtYXR0ZXI6ICh2KSA9PiBmb3JtYXRQaG9uZShTdHJpbmcodikpLFxuICAgICAgfSxcbiAgICAgIHtcbiAgICAgICAgaGVhZGVyOiBcIlN0YXR1c1wiLFxuICAgICAgICBrZXk6IFwic3RhdHVzXCIsXG4gICAgICAgIHdpZHRoOiAxMixcbiAgICAgICAgZm9ybWF0dGVyOiAodikgPT4gZm9ybWF0U3RhdHVzKFN0cmluZyh2KSksXG4gICAgICB9LFxuICAgICAge1xuICAgICAgICBoZWFkZXI6IFwiU2NoZWR1bGVkIEZvclwiLFxuICAgICAgICBrZXk6IFwic2NoZWR1bGVkQXRcIixcbiAgICAgICAgd2lkdGg6IDIwLFxuICAgICAgICBmb3JtYXR0ZXI6ICh2KSA9PiB7XG4gICAgICAgICAgY29uc3QgZGF0ZSA9IG5ldyBEYXRlKFN0cmluZyh2KSk7XG4gICAgICAgICAgcmV0dXJuIGNvbG9ycy5jb2RlKGRhdGUudG9Mb2NhbGVTdHJpbmcoKSk7XG4gICAgICAgIH0sXG4gICAgICB9LFxuICAgICAge1xuICAgICAgICBoZWFkZXI6IFwiVGV4dFwiLFxuICAgICAgICBrZXk6IFwidGV4dFwiLFxuICAgICAgICB3aWR0aDogMjUsXG4gICAgICAgIGZvcm1hdHRlcjogKHYpID0+IHtcbiAgICAgICAgICBjb25zdCB0ZXh0ID0gU3RyaW5nKHYpO1xuICAgICAgICAgIHJldHVybiB0ZXh0Lmxlbmd0aCA+IDIyID8gdGV4dC5zbGljZSgwLCAyMikgKyBcIi4uLlwiIDogdGV4dDtcbiAgICAgICAgfSxcbiAgICAgIH0sXG4gICAgXSk7XG4gIH1cbn1cbiJdfQ==

package/dist/commands/sms/send.d.ts

@@ -0,0 +1,13 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class SmsSend extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        to: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        text: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        from: 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/sms/send.js

@@ -0,0 +1,70 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { success, error, spinner, formatStatus, formatCredits, json, isJsonMode, } from "../../lib/output.js";
+export default class SmsSend extends AuthenticatedCommand {
+    static description = "Send an SMS message";
+    static examples = [
+        '<%= config.bin %> sms send --to +15551234567 --text "Hello!"',
+        '<%= config.bin %> sms send --to +15551234567 --text "Hello!" --from "Sendly"',
+        '<%= config.bin %> sms send --to +15551234567 --text "Hello!" --json',
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        to: Flags.string({
+            char: "t",
+            description: "Recipient phone number (E.164 format)",
+            required: true,
+        }),
+        text: Flags.string({
+            char: "m",
+            description: "Message text",
+            required: true,
+        }),
+        from: Flags.string({
+            char: "f",
+            description: "Sender ID or phone number",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SmsSend);
+        // Validate phone number format
+        if (!/^\+[1-9]\d{1,14}$/.test(flags.to)) {
+            error("Invalid phone number format", {
+                hint: "Use E.164 format: +15551234567",
+            });
+            this.exit(1);
+        }
+        // Validate message text
+        if (!flags.text.trim()) {
+            error("Message text cannot be empty");
+            this.exit(1);
+        }
+        const spin = spinner("Sending message...");
+        spin.start();
+        try {
+            const response = await apiClient.post("/api/v1/messages", {
+                to: flags.to,
+                text: flags.text,
+                ...(flags.from && { from: flags.from }),
+            });
+            spin.stop();
+            if (isJsonMode()) {
+                json(response);
+                return;
+            }
+            success("Message sent", {
+                ID: response.id,
+                To: response.to,
+                Status: formatStatus(response.status),
+                Segments: response.segments,
+                Credits: formatCredits(response.creditsUsed),
+            });
+        }
+        catch (err) {
+            spin.stop();
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,10 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class WebhooksList extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    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/list.js

@@ -0,0 +1,80 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { table, json, info, colors, isJsonMode, } from "../../lib/output.js";
+export default class WebhooksList extends AuthenticatedCommand {
+    static description = "List configured webhooks";
+    static examples = [
+        "<%= config.bin %> webhooks list",
+        "<%= config.bin %> webhooks list --json",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const webhooks = await apiClient.get("/api/webhooks");
+        if (isJsonMode()) {
+            json(webhooks);
+            return;
+        }
+        if (webhooks.length === 0) {
+            info("No webhooks configured");
+            console.log();
+            console.log(`  Create one with ${colors.code("sendly webhooks create")}`);
+            console.log(`  Or test locally with ${colors.code("sendly webhooks listen")}`);
+            return;
+        }
+        console.log();
+        table(webhooks, [
+            {
+                header: "ID",
+                key: "id",
+                width: 18,
+                formatter: (v) => colors.dim(String(v).slice(0, 15) + "..."),
+            },
+            {
+                header: "URL",
+                key: "url",
+                width: 35,
+                formatter: (v) => {
+                    const url = String(v);
+                    return url.length > 32 ? url.slice(0, 32) + "..." : url;
+                },
+            },
+            {
+                header: "Events",
+                key: "events",
+                width: 15,
+                formatter: (v) => {
+                    const events = v;
+                    return events.length > 2
+                        ? `${events.length} events`
+                        : events.join(", ").replace(/message\./g, "");
+                },
+            },
+            {
+                header: "Status",
+                key: "isActive",
+                width: 10,
+                formatter: (v) => v ? colors.success("active") : colors.error("disabled"),
+            },
+            {
+                header: "Circuit",
+                key: "circuitState",
+                width: 10,
+                formatter: (v) => {
+                    switch (v) {
+                        case "closed":
+                            return colors.success("closed");
+                        case "open":
+                            return colors.error("open");
+                        case "half_open":
+                            return colors.warning("half_open");
+                        default:
+                            return String(v);
+                    }
+                },
+            },
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21tYW5kcy93ZWJob29rcy9saXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNwRCxPQUFPLEVBQ0wsS0FBSyxFQUNMLElBQUksRUFDSixJQUFJLEVBRUosTUFBTSxFQUNOLFVBQVUsR0FDWCxNQUFNLHFCQUFxQixDQUFDO0FBYTdCLE1BQU0sQ0FBQyxPQUFPLE9BQU8sWUFBYSxTQUFRLG9CQUFvQjtJQUM1RCxNQUFNLENBQUMsV0FBVyxHQUFHLDBCQUEwQixDQUFDO0lBRWhELE1BQU0sQ0FBQyxRQUFRLEdBQUc7UUFDaEIsaUNBQWlDO1FBQ2pDLHdDQUF3QztLQUN6QyxDQUFDO0lBRUYsTUFBTSxDQUFDLEtBQUssR0FBRztRQUNiLEdBQUcsb0JBQW9CLENBQUMsU0FBUztLQUNsQyxDQUFDO0lBRUYsS0FBSyxDQUFDLEdBQUc7UUFDUCxNQUFNLFFBQVEsR0FBRyxNQUFNLFNBQVMsQ0FBQyxHQUFHLENBQVksZUFBZSxDQUFDLENBQUM7UUFFakUsSUFBSSxVQUFVLEVBQUUsRUFBRSxDQUFDO1lBQ2pCLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztZQUNmLE9BQU87UUFDVCxDQUFDO1FBRUQsSUFBSSxRQUFRLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1lBQzFCLElBQUksQ0FBQyx3QkFBd0IsQ0FBQyxDQUFDO1lBQy9CLE9BQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQztZQUNkLE9BQU8sQ0FBQyxHQUFHLENBQUMscUJBQXFCLE1BQU0sQ0FBQyxJQUFJLENBQUMsd0JBQXdCLENBQUMsRUFBRSxDQUFDLENBQUM7WUFDMUUsT0FBTyxDQUFDLEdBQUcsQ0FBQywwQkFBMEIsTUFBTSxDQUFDLElBQUksQ0FBQyx3QkFBd0IsQ0FBQyxFQUFFLENBQUMsQ0FBQztZQUMvRSxPQUFPO1FBQ1QsQ0FBQztRQUVELE9BQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUVkLEtBQUssQ0FBQyxRQUFRLEVBQUU7WUFDZDtnQkFDRSxNQUFNLEVBQUUsSUFBSTtnQkFDWixHQUFHLEVBQUUsSUFBSTtnQkFDVCxLQUFLLEVBQUUsRUFBRTtnQkFDVCxTQUFTLEVBQUUsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLEdBQUcsS0FBSyxDQUFDO2FBQzdEO1lBQ0Q7Z0JBQ0UsTUFBTSxFQUFFLEtBQUs7Z0JBQ2IsR0FBRyxFQUFFLEtBQUs7Z0JBQ1YsS0FBSyxFQUFFLEVBQUU7Z0JBQ1QsU0FBUyxFQUFFLENBQUMsQ0FBQyxFQUFFLEVBQUU7b0JBQ2YsTUFBTSxHQUFHLEdBQUcsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDO29CQUN0QixPQUFPLEdBQUcsQ0FBQyxNQUFNLEdBQUcsRUFBRSxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsR0FBRyxLQUFLLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQztnQkFDMUQsQ0FBQzthQUNGO1lBQ0Q7Z0JBQ0UsTUFBTSxFQUFFLFFBQVE7Z0JBQ2hCLEdBQUcsRUFBRSxRQUFRO2dCQUNiLEtBQUssRUFBRSxFQUFFO2dCQUNULFNBQVMsRUFBRSxDQUFDLENBQUMsRUFBRSxFQUFFO29CQUNmLE1BQU0sTUFBTSxHQUFHLENBQWEsQ0FBQztvQkFDN0IsT0FBTyxNQUFNLENBQUMsTUFBTSxHQUFHLENBQUM7d0JBQ3RCLENBQUMsQ0FBQyxHQUFHLE1BQU0sQ0FBQyxNQUFNLFNBQVM7d0JBQzNCLENBQUMsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLE9BQU8sQ0FBQyxZQUFZLEVBQUUsRUFBRSxDQUFDLENBQUM7Z0JBQ2xELENBQUM7YUFDRjtZQUNEO2dCQUNFLE1BQU0sRUFBRSxRQUFRO2dCQUNoQixHQUFHLEVBQUUsVUFBVTtnQkFDZixLQUFLLEVBQUUsRUFBRTtnQkFDVCxTQUFTLEVBQUUsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUNmLENBQUMsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUM7YUFDMUQ7WUFDRDtnQkFDRSxNQUFNLEVBQUUsU0FBUztnQkFDakIsR0FBRyxFQUFFLGNBQWM7Z0JBQ25CLEtBQUssRUFBRSxFQUFFO2dCQUNULFNBQVMsRUFBRSxDQUFDLENBQUMsRUFBRSxFQUFFO29CQUNmLFFBQVEsQ0FBQyxFQUFFLENBQUM7d0JBQ1YsS0FBSyxRQUFROzRCQUNYLE9BQU8sTUFBTSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQzt3QkFDbEMsS0FBSyxNQUFNOzRCQUNULE9BQU8sTUFBTSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQzt3QkFDOUIsS0FBSyxXQUFXOzRCQUNkLE9BQU8sTUFBTSxDQUFDLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQzt3QkFDckM7NEJBQ0UsT0FBTyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUM7b0JBQ3JCLENBQUM7Z0JBQ0gsQ0FBQzthQUNGO1NBQ0YsQ0FBQyxDQUFDO0lBQ0wsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEF1dGhlbnRpY2F0ZWRDb21tYW5kIH0gZnJvbSBcIi4uLy4uL2xpYi9iYXNlLWNvbW1hbmQuanNcIjtcbmltcG9ydCB7IGFwaUNsaWVudCB9IGZyb20gXCIuLi8uLi9saWIvYXBpLWNsaWVudC5qc1wiO1xuaW1wb3J0IHtcbiAgdGFibGUsXG4gIGpzb24sXG4gIGluZm8sXG4gIGZvcm1hdFN0YXR1cyxcbiAgY29sb3JzLFxuICBpc0pzb25Nb2RlLFxufSBmcm9tIFwiLi4vLi4vbGliL291dHB1dC5qc1wiO1xuXG5pbnRlcmZhY2UgV2ViaG9vayB7XG4gIGlkOiBzdHJpbmc7XG4gIHVybDogc3RyaW5nO1xuICBkZXNjcmlwdGlvbj86IHN0cmluZztcbiAgZXZlbnRzOiBzdHJpbmdbXTtcbiAgaXNBY3RpdmU6IGJvb2xlYW47XG4gIGZhaWx1cmVDb3VudDogbnVtYmVyO1xuICBjaXJjdWl0U3RhdGU6IFwiY2xvc2VkXCIgfCBcIm9wZW5cIiB8IFwiaGFsZl9vcGVuXCI7XG4gIGNyZWF0ZWRBdDogc3RyaW5nO1xufVxuXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBXZWJob29rc0xpc3QgZXh0ZW5kcyBBdXRoZW50aWNhdGVkQ29tbWFuZCB7XG4gIHN0YXRpYyBkZXNjcmlwdGlvbiA9IFwiTGlzdCBjb25maWd1cmVkIHdlYmhvb2tzXCI7XG5cbiAgc3RhdGljIGV4YW1wbGVzID0gW1xuICAgIFwiPCU9IGNvbmZpZy5iaW4gJT4gd2ViaG9va3MgbGlzdFwiLFxuICAgIFwiPCU9IGNvbmZpZy5iaW4gJT4gd2ViaG9va3MgbGlzdCAtLWpzb25cIixcbiAgXTtcblxuICBzdGF0aWMgZmxhZ3MgPSB7XG4gICAgLi4uQXV0aGVudGljYXRlZENvbW1hbmQuYmFzZUZsYWdzLFxuICB9O1xuXG4gIGFzeW5jIHJ1bigpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBjb25zdCB3ZWJob29rcyA9IGF3YWl0IGFwaUNsaWVudC5nZXQ8V2ViaG9va1tdPihcIi9hcGkvd2ViaG9va3NcIik7XG5cbiAgICBpZiAoaXNKc29uTW9kZSgpKSB7XG4gICAgICBqc29uKHdlYmhvb2tzKTtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICBpZiAod2ViaG9va3MubGVuZ3RoID09PSAwKSB7XG4gICAgICBpbmZvKFwiTm8gd2ViaG9va3MgY29uZmlndXJlZFwiKTtcbiAgICAgIGNvbnNvbGUubG9nKCk7XG4gICAgICBjb25zb2xlLmxvZyhgICBDcmVhdGUgb25lIHdpdGggJHtjb2xvcnMuY29kZShcInNlbmRseSB3ZWJob29rcyBjcmVhdGVcIil9YCk7XG4gICAgICBjb25zb2xlLmxvZyhgICBPciB0ZXN0IGxvY2FsbHkgd2l0aCAke2NvbG9ycy5jb2RlKFwic2VuZGx5IHdlYmhvb2tzIGxpc3RlblwiKX1gKTtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICBjb25zb2xlLmxvZygpO1xuXG4gICAgdGFibGUod2ViaG9va3MsIFtcbiAgICAgIHtcbiAgICAgICAgaGVhZGVyOiBcIklEXCIsXG4gICAgICAgIGtleTogXCJpZFwiLFxuICAgICAgICB3aWR0aDogMTgsXG4gICAgICAgIGZvcm1hdHRlcjogKHYpID0+IGNvbG9ycy5kaW0oU3RyaW5nKHYpLnNsaWNlKDAsIDE1KSArIFwiLi4uXCIpLFxuICAgICAgfSxcbiAgICAgIHtcbiAgICAgICAgaGVhZGVyOiBcIlVSTFwiLFxuICAgICAgICBrZXk6IFwidXJsXCIsXG4gICAgICAgIHdpZHRoOiAzNSxcbiAgICAgICAgZm9ybWF0dGVyOiAodikgPT4ge1xuICAgICAgICAgIGNvbnN0IHVybCA9IFN0cmluZyh2KTtcbiAgICAgICAgICByZXR1cm4gdXJsLmxlbmd0aCA+IDMyID8gdXJsLnNsaWNlKDAsIDMyKSArIFwiLi4uXCIgOiB1cmw7XG4gICAgICAgIH0sXG4gICAgICB9LFxuICAgICAge1xuICAgICAgICBoZWFkZXI6IFwiRXZlbnRzXCIsXG4gICAgICAgIGtleTogXCJldmVudHNcIixcbiAgICAgICAgd2lkdGg6IDE1LFxuICAgICAgICBmb3JtYXR0ZXI6ICh2KSA9PiB7XG4gICAgICAgICAgY29uc3QgZXZlbnRzID0gdiBhcyBzdHJpbmdbXTtcbiAgICAgICAgICByZXR1cm4gZXZlbnRzLmxlbmd0aCA+IDJcbiAgICAgICAgICAgID8gYCR7ZXZlbnRzLmxlbmd0aH0gZXZlbnRzYFxuICAgICAgICAgICAgOiBldmVudHMuam9pbihcIiwgXCIpLnJlcGxhY2UoL21lc3NhZ2VcXC4vZywgXCJcIik7XG4gICAgICAgIH0sXG4gICAgICB9LFxuICAgICAge1xuICAgICAgICBoZWFkZXI6IFwiU3RhdHVzXCIsXG4gICAgICAgIGtleTogXCJpc0FjdGl2ZVwiLFxuICAgICAgICB3aWR0aDogMTAsXG4gICAgICAgIGZvcm1hdHRlcjogKHYpID0+XG4gICAgICAgICAgdiA/IGNvbG9ycy5zdWNjZXNzKFwiYWN0aXZlXCIpIDogY29sb3JzLmVycm9yKFwiZGlzYWJsZWRcIiksXG4gICAgICB9LFxuICAgICAge1xuICAgICAgICBoZWFkZXI6IFwiQ2lyY3VpdFwiLFxuICAgICAgICBrZXk6IFwiY2lyY3VpdFN0YXRlXCIsXG4gICAgICAgIHdpZHRoOiAxMCxcbiAgICAgICAgZm9ybWF0dGVyOiAodikgPT4ge1xuICAgICAgICAgIHN3aXRjaCAodikge1xuICAgICAgICAgICAgY2FzZSBcImNsb3NlZFwiOlxuICAgICAgICAgICAgICByZXR1cm4gY29sb3JzLnN1Y2Nlc3MoXCJjbG9zZWRcIik7XG4gICAgICAgICAgICBjYXNlIFwib3BlblwiOlxuICAgICAgICAgICAgICByZXR1cm4gY29sb3JzLmVycm9yKFwib3BlblwiKTtcbiAgICAgICAgICAgIGNhc2UgXCJoYWxmX29wZW5cIjpcbiAgICAgICAgICAgICAgcmV0dXJuIGNvbG9ycy53YXJuaW5nKFwiaGFsZl9vcGVuXCIpO1xuICAgICAgICAgICAgZGVmYXVsdDpcbiAgICAgICAgICAgICAgcmV0dXJuIFN0cmluZyh2KTtcbiAgICAgICAgICB9XG4gICAgICAgIH0sXG4gICAgICB9LFxuICAgIF0pO1xuICB9XG59XG4iXX0=

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

@@ -0,0 +1,20 @@
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+export default class WebhooksListen extends AuthenticatedCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        forward: 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>;
+        port: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number | 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>;
+    };
+    private tunnel;
+    private webhookId;
+    run(): Promise<void>;
+    private pollEvents;
+    private displayEvent;
+    private forwardEvent;
+    private generateSignature;
+    private cleanup;
+}

package/dist/commands/webhooks/listen.js

@@ -0,0 +1,202 @@
+import { Flags } from "@oclif/core";
+import { AuthenticatedCommand } from "../../lib/base-command.js";
+import { apiClient } from "../../lib/api-client.js";
+import { error, warn, colors, spinner, } from "../../lib/output.js";
+import { getConfigValue } from "../../lib/config.js";
+import localtunnel from "localtunnel";
+export default class WebhooksListen extends AuthenticatedCommand {
+    static description = "Listen for webhooks locally (like Stripe CLI). Creates a secure tunnel to forward events to your local server.";
+    static examples = [
+        "<%= config.bin %> webhooks listen",
+        "<%= config.bin %> webhooks listen --forward http://localhost:3000/webhook",
+        "<%= config.bin %> webhooks listen --events message.delivered,message.failed",
+    ];
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+        forward: Flags.string({
+            char: "f",
+            description: "Local URL to forward events to",
+            default: "http://localhost:3000/webhook",
+        }),
+        events: Flags.string({
+            char: "e",
+            description: "Comma-separated list of events to listen for",
+            default: "message.sent,message.delivered,message.failed,message.bounced",
+        }),
+        port: Flags.integer({
+            char: "p",
+            description: "Local port for the tunnel (auto-detected from forward URL if not specified)",
+        }),
+    };
+    tunnel = null;
+    webhookId = null;
+    async run() {
+        const { flags } = await this.parse(WebhooksListen);
+        const forwardUrl = new URL(flags.forward);
+        const localPort = flags.port || parseInt(forwardUrl.port) || 3000;
+        const events = flags.events.split(",").map((e) => e.trim());
+        const spin = spinner("Starting webhook listener...");
+        spin.start();
+        try {
+            // Create localtunnel
+            this.tunnel = await localtunnel({
+                port: localPort,
+                subdomain: `sendly-${Date.now().toString(36)}`,
+            });
+            const tunnelUrl = this.tunnel.url;
+            spin.succeed("Tunnel established");
+            // Register temporary webhook with Sendly
+            const webhookResponse = await apiClient.post("/api/cli/webhooks/listen", {
+                url: `${tunnelUrl}/cli-webhook`,
+                events,
+                forwardUrl: flags.forward,
+            });
+            this.webhookId = webhookResponse.id;
+            const secret = webhookResponse.secret;
+            // Display connection info
+            console.log();
+            console.log(colors.bold(colors.primary("Webhook listener ready!")));
+            console.log();
+            console.log(`  ${colors.dim("Tunnel URL:")}     ${colors.code(tunnelUrl)}`);
+            console.log(`  ${colors.dim("Forwarding to:")} ${colors.code(flags.forward)}`);
+            console.log(`  ${colors.dim("Events:")}        ${events.join(", ")}`);
+            console.log();
+            console.log(`  ${colors.dim("Webhook Secret:")}`);
+            console.log(`  ${colors.primary(secret)}`);
+            console.log();
+            console.log(colors.dim("Use this secret to verify webhook signatures in your app."));
+            console.log();
+            console.log(colors.bold("Waiting for events..."));
+            console.log(colors.dim("─".repeat(60)));
+            console.log();
+            // Set up event forwarding
+            this.tunnel.on("request", (info) => {
+                // This is just for logging - actual forwarding happens server-side
+            });
+            // Handle tunnel close
+            this.tunnel.on("close", () => {
+                warn("Tunnel closed");
+                this.cleanup();
+                process.exit(0);
+            });
+            this.tunnel.on("error", (err) => {
+                error(`Tunnel error: ${err.message}`);
+            });
+            // Poll for events and display them
+            await this.pollEvents(flags.forward, secret);
+        }
+        catch (err) {
+            spin.fail("Failed to start listener");
+            throw err;
+        }
+    }
+    async pollEvents(forwardUrl, secret) {
+        const baseUrl = getConfigValue("baseUrl") || "https://sendly.live";
+        // Set up SSE connection for real-time events
+        const eventSource = new EventSource(`${baseUrl}/api/cli/webhooks/events?webhookId=${this.webhookId}`, {
+            // @ts-ignore - headers not in type but supported
+            headers: {
+                Authorization: `Bearer ${getConfigValue("apiKey") || getConfigValue("accessToken")}`,
+            },
+        });
+        // Fallback to polling if SSE not available
+        const pollInterval = setInterval(async () => {
+            try {
+                const events = await apiClient.get(`/api/cli/webhooks/events?webhookId=${this.webhookId}&since=${Date.now() - 5000}`);
+                for (const event of events) {
+                    this.displayEvent(event);
+                    await this.forwardEvent(forwardUrl, event, secret);
+                }
+            }
+            catch {
+                // Ignore polling errors
+            }
+        }, 2000);
+        // Handle graceful shutdown
+        const cleanup = () => {
+            clearInterval(pollInterval);
+            this.cleanup();
+            process.exit(0);
+        };
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+        // Keep process alive
+        await new Promise(() => { });
+    }
+    displayEvent(event) {
+        const timestamp = new Date(event.created * 1000).toLocaleTimeString();
+        const eventType = event.type;
+        let statusColor = colors.info;
+        if (eventType.includes("delivered"))
+            statusColor = colors.success;
+        if (eventType.includes("failed"))
+            statusColor = colors.error;
+        console.log(`${colors.dim(timestamp)} ${statusColor("→")} ${colors.bold(eventType)}`);
+        if (event.data) {
+            const messageId = event.data.message_id || event.data.id;
+            const to = event.data.to;
+            if (messageId) {
+                console.log(`  ${colors.dim("message_id:")} ${messageId}`);
+            }
+            if (to) {
+                console.log(`  ${colors.dim("to:")} ${to}`);
+            }
+        }
+        console.log();
+    }
+    async forwardEvent(forwardUrl, event, secret) {
+        try {
+            const payload = JSON.stringify(event);
+            const signature = await this.generateSignature(payload, secret);
+            const response = await fetch(forwardUrl, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "X-Sendly-Signature": signature,
+                    "X-Sendly-Event": event.type,
+                },
+                body: payload,
+            });
+            if (response.ok) {
+                console.log(`  ${colors.success("✓")} Forwarded to ${forwardUrl} (${response.status})`);
+            }
+            else {
+                console.log(`  ${colors.error("✗")} Forward failed (${response.status})`);
+            }
+        }
+        catch (err) {
+            console.log(`  ${colors.error("✗")} Forward error: ${err.message}`);
+        }
+        console.log();
+    }
+    async generateSignature(payload, secret) {
+        const encoder = new TextEncoder();
+        const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+        const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(payload));
+        const hashArray = Array.from(new Uint8Array(signature));
+        const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+        return `v1=${hashHex}`;
+    }
+    async cleanup() {
+        // Clean up tunnel
+        if (this.tunnel) {
+            this.tunnel.close();
+        }
+        // Clean up temporary webhook
+        if (this.webhookId) {
+            try {
+                await apiClient.delete(`/api/cli/webhooks/listen/${this.webhookId}`);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    }
+}
+// Polyfill EventSource for Node.js if needed
+class EventSource {
+    constructor(url, options) {
+        // Simple implementation - in production use a proper polyfill
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"listen.js","sourceRoot":"","sources":["../../../src/commands/webhooks/listen.ts"],"names":[],"mappings":"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","sourcesContent":["import { Flags } from \"@oclif/core\";\nimport { AuthenticatedCommand } from \"../../lib/base-command.js\";\nimport { apiClient } from \"../../lib/api-client.js\";\nimport {\n  success,\n  error,\n  info,\n  warn,\n  colors,\n  formatStatus,\n  formatDate,\n  spinner,\n  json as jsonOutput,\n  isJsonMode,\n} from \"../../lib/output.js\";\nimport { getConfigValue } from \"../../lib/config.js\";\nimport localtunnel from \"localtunnel\";\n\ninterface WebhookEvent {\n  id: string;\n  type: string;\n  data: Record<string, unknown>;\n  created: number;\n}\n\nexport default class WebhooksListen extends AuthenticatedCommand {\n  static description =\n    \"Listen for webhooks locally (like Stripe CLI). Creates a secure tunnel to forward events to your local server.\";\n\n  static examples = [\n    \"<%= config.bin %> webhooks listen\",\n    \"<%= config.bin %> webhooks listen --forward http://localhost:3000/webhook\",\n    \"<%= config.bin %> webhooks listen --events message.delivered,message.failed\",\n  ];\n\n  static flags = {\n    ...AuthenticatedCommand.baseFlags,\n    forward: Flags.string({\n      char: \"f\",\n      description: \"Local URL to forward events to\",\n      default: \"http://localhost:3000/webhook\",\n    }),\n    events: Flags.string({\n      char: \"e\",\n      description: \"Comma-separated list of events to listen for\",\n      default: \"message.sent,message.delivered,message.failed,message.bounced\",\n    }),\n    port: Flags.integer({\n      char: \"p\",\n      description: \"Local port for the tunnel (auto-detected from forward URL if not specified)\",\n    }),\n  };\n\n  private tunnel: localtunnel.Tunnel | null = null;\n  private webhookId: string | null = null;\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(WebhooksListen);\n\n    const forwardUrl = new URL(flags.forward);\n    const localPort = flags.port || parseInt(forwardUrl.port) || 3000;\n    const events = flags.events.split(\",\").map((e) => e.trim());\n\n    const spin = spinner(\"Starting webhook listener...\");\n    spin.start();\n\n    try {\n      // Create localtunnel\n      this.tunnel = await localtunnel({\n        port: localPort,\n        subdomain: `sendly-${Date.now().toString(36)}`,\n      });\n\n      const tunnelUrl = this.tunnel.url;\n      spin.succeed(\"Tunnel established\");\n\n      // Register temporary webhook with Sendly\n      const webhookResponse = await apiClient.post<{\n        id: string;\n        secret: string;\n      }>(\"/api/cli/webhooks/listen\", {\n        url: `${tunnelUrl}/cli-webhook`,\n        events,\n        forwardUrl: flags.forward,\n      });\n\n      this.webhookId = webhookResponse.id;\n      const secret = webhookResponse.secret;\n\n      // Display connection info\n      console.log();\n      console.log(colors.bold(colors.primary(\"Webhook listener ready!\")));\n      console.log();\n      console.log(`  ${colors.dim(\"Tunnel URL:\")}     ${colors.code(tunnelUrl)}`);\n      console.log(`  ${colors.dim(\"Forwarding to:\")} ${colors.code(flags.forward)}`);\n      console.log(`  ${colors.dim(\"Events:\")}        ${events.join(\", \")}`);\n      console.log();\n      console.log(`  ${colors.dim(\"Webhook Secret:\")}`);\n      console.log(`  ${colors.primary(secret)}`);\n      console.log();\n      console.log(colors.dim(\"Use this secret to verify webhook signatures in your app.\"));\n      console.log();\n      console.log(colors.bold(\"Waiting for events...\"));\n      console.log(colors.dim(\"─\".repeat(60)));\n      console.log();\n\n      // Set up event forwarding\n      this.tunnel.on(\"request\", (info) => {\n        // This is just for logging - actual forwarding happens server-side\n      });\n\n      // Handle tunnel close\n      this.tunnel.on(\"close\", () => {\n        warn(\"Tunnel closed\");\n        this.cleanup();\n        process.exit(0);\n      });\n\n      this.tunnel.on(\"error\", (err) => {\n        error(`Tunnel error: ${err.message}`);\n      });\n\n      // Poll for events and display them\n      await this.pollEvents(flags.forward, secret);\n    } catch (err) {\n      spin.fail(\"Failed to start listener\");\n      throw err;\n    }\n  }\n\n  private async pollEvents(forwardUrl: string, secret: string): Promise<void> {\n    const baseUrl = getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n\n    // Set up SSE connection for real-time events\n    const eventSource = new EventSource(\n      `${baseUrl}/api/cli/webhooks/events?webhookId=${this.webhookId}`,\n      {\n        // @ts-ignore - headers not in type but supported\n        headers: {\n          Authorization: `Bearer ${getConfigValue(\"apiKey\") || getConfigValue(\"accessToken\")}`,\n        },\n      }\n    );\n\n    // Fallback to polling if SSE not available\n    const pollInterval = setInterval(async () => {\n      try {\n        const events = await apiClient.get<WebhookEvent[]>(\n          `/api/cli/webhooks/events?webhookId=${this.webhookId}&since=${Date.now() - 5000}`\n        );\n\n        for (const event of events) {\n          this.displayEvent(event);\n          await this.forwardEvent(forwardUrl, event, secret);\n        }\n      } catch {\n        // Ignore polling errors\n      }\n    }, 2000);\n\n    // Handle graceful shutdown\n    const cleanup = () => {\n      clearInterval(pollInterval);\n      this.cleanup();\n      process.exit(0);\n    };\n\n    process.on(\"SIGINT\", cleanup);\n    process.on(\"SIGTERM\", cleanup);\n\n    // Keep process alive\n    await new Promise(() => {});\n  }\n\n  private displayEvent(event: WebhookEvent): void {\n    const timestamp = new Date(event.created * 1000).toLocaleTimeString();\n    const eventType = event.type;\n\n    let statusColor = colors.info;\n    if (eventType.includes(\"delivered\")) statusColor = colors.success;\n    if (eventType.includes(\"failed\")) statusColor = colors.error;\n\n    console.log(\n      `${colors.dim(timestamp)} ${statusColor(\"→\")} ${colors.bold(eventType)}`\n    );\n\n    if (event.data) {\n      const messageId = (event.data as any).message_id || (event.data as any).id;\n      const to = (event.data as any).to;\n      if (messageId) {\n        console.log(`  ${colors.dim(\"message_id:\")} ${messageId}`);\n      }\n      if (to) {\n        console.log(`  ${colors.dim(\"to:\")} ${to}`);\n      }\n    }\n    console.log();\n  }\n\n  private async forwardEvent(\n    forwardUrl: string,\n    event: WebhookEvent,\n    secret: string\n  ): Promise<void> {\n    try {\n      const payload = JSON.stringify(event);\n      const signature = await this.generateSignature(payload, secret);\n\n      const response = await fetch(forwardUrl, {\n        method: \"POST\",\n        headers: {\n          \"Content-Type\": \"application/json\",\n          \"X-Sendly-Signature\": signature,\n          \"X-Sendly-Event\": event.type,\n        },\n        body: payload,\n      });\n\n      if (response.ok) {\n        console.log(\n          `  ${colors.success(\"✓\")} Forwarded to ${forwardUrl} (${response.status})`\n        );\n      } else {\n        console.log(\n          `  ${colors.error(\"✗\")} Forward failed (${response.status})`\n        );\n      }\n    } catch (err) {\n      console.log(\n        `  ${colors.error(\"✗\")} Forward error: ${(err as Error).message}`\n      );\n    }\n    console.log();\n  }\n\n  private async generateSignature(\n    payload: string,\n    secret: string\n  ): Promise<string> {\n    const encoder = new TextEncoder();\n    const key = await crypto.subtle.importKey(\n      \"raw\",\n      encoder.encode(secret),\n      { name: \"HMAC\", hash: \"SHA-256\" },\n      false,\n      [\"sign\"]\n    );\n    const signature = await crypto.subtle.sign(\n      \"HMAC\",\n      key,\n      encoder.encode(payload)\n    );\n    const hashArray = Array.from(new Uint8Array(signature));\n    const hashHex = hashArray.map((b) => b.toString(16).padStart(2, \"0\")).join(\"\");\n    return `v1=${hashHex}`;\n  }\n\n  private async cleanup(): Promise<void> {\n    // Clean up tunnel\n    if (this.tunnel) {\n      this.tunnel.close();\n    }\n\n    // Clean up temporary webhook\n    if (this.webhookId) {\n      try {\n        await apiClient.delete(`/api/cli/webhooks/listen/${this.webhookId}`);\n      } catch {\n        // Ignore cleanup errors\n      }\n    }\n  }\n}\n\n// Polyfill EventSource for Node.js if needed\nclass EventSource {\n  constructor(url: string, options?: any) {\n    // Simple implementation - in production use a proper polyfill\n  }\n}\n"]}

package/dist/commands/whoami.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from "../lib/base-command.js";
+export default class Whoami extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    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/whoami.js

@@ -0,0 +1,51 @@
+import { BaseCommand } from "../lib/base-command.js";
+import { getAuthInfo } from "../lib/auth.js";
+import { success, info, keyValue, colors, json } from "../lib/output.js";
+import { getConfigPath } from "../lib/config.js";
+export default class Whoami extends BaseCommand {
+    static description = "Show current authentication status";
+    static examples = ["<%= config.bin %> whoami"];
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    async run() {
+        const { flags } = await this.parse(Whoami);
+        const authInfo = await getAuthInfo();
+        if (flags.json) {
+            json({
+                authenticated: authInfo.authenticated,
+                email: authInfo.email,
+                userId: authInfo.userId,
+                environment: authInfo.environment,
+                keyType: authInfo.keyType,
+                configPath: getConfigPath(),
+            });
+            return;
+        }
+        if (!authInfo.authenticated) {
+            info("Not logged in");
+            console.log();
+            console.log(`  Run ${colors.code("sendly login")} to authenticate`);
+            return;
+        }
+        success("Authenticated");
+        console.log();
+        const displayData = {
+            Environment: colors.primary(authInfo.environment),
+        };
+        if (authInfo.email) {
+            displayData["Email"] = authInfo.email;
+        }
+        if (authInfo.keyType) {
+            displayData["Key Type"] = authInfo.keyType === "test"
+                ? colors.warning("test")
+                : colors.success("live");
+        }
+        if (authInfo.userId) {
+            displayData["User ID"] = colors.dim(authInfo.userId);
+        }
+        displayData["Config"] = colors.dim(getConfigPath());
+        keyValue(displayData);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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