@sendly/cli 3.5.4 → 3.6.1

package/README.md

@@ -221,7 +221,7 @@ sendly config get baseUrl
 #### Set Configuration Value
 
 ```bash
-sendly config set baseUrl https://api.sendly.live
+sendly config set baseUrl https://sendly.live
 ```
 
 #### List All Configuration

package/dist/commands/logout.js

@@ -1,7 +1,8 @@
 import { BaseCommand } from "../lib/base-command.js";
 import { logout } from "../lib/auth.js";
 import { success, info } from "../lib/output.js";
-import { isAuthenticated } from "../lib/config.js";
+import { isAuthenticated, getAuthToken } from "../lib/config.js";
+import { apiClient } from "../lib/api-client.js";
 export default class Logout extends BaseCommand {
     static description = "Log out of Sendly";
     static examples = ["<%= config.bin %> logout"];
@@ -13,8 +14,20 @@ export default class Logout extends BaseCommand {
             info("Not currently logged in");
             return;
         }
+        const token = getAuthToken();
+        // Revoke token server-side first (if it's a CLI session token)
+        if (token?.startsWith("cli_")) {
+            try {
+                await apiClient.post("/api/cli/auth/logout", {}, true);
+            }
+            catch {
+                // Continue with local logout even if server revocation fails
+                // This handles offline scenarios and ensures user can always logout
+            }
+        }
+        // Clear local credentials
         logout();
         success("Logged out successfully");
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nb3V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbW1hbmRzL2xvZ291dC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDckQsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3hDLE9BQU8sRUFBRSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDakQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRW5ELE1BQU0sQ0FBQyxPQUFPLE9BQU8sTUFBTyxTQUFRLFdBQVc7SUFDN0MsTUFBTSxDQUFDLFdBQVcsR0FBRyxtQkFBbUIsQ0FBQztJQUV6QyxNQUFNLENBQUMsUUFBUSxHQUFHLENBQUMsMEJBQTBCLENBQUMsQ0FBQztJQUUvQyxNQUFNLENBQUMsS0FBSyxHQUFHO1FBQ2IsR0FBRyxXQUFXLENBQUMsU0FBUztLQUN6QixDQUFDO0lBRUYsS0FBSyxDQUFDLEdBQUc7UUFDUCxJQUFJLENBQUMsZUFBZSxFQUFFLEVBQUUsQ0FBQztZQUN2QixJQUFJLENBQUMseUJBQXlCLENBQUMsQ0FBQztZQUNoQyxPQUFPO1FBQ1QsQ0FBQztRQUVELE1BQU0sRUFBRSxDQUFDO1FBQ1QsT0FBTyxDQUFDLHlCQUF5QixDQUFDLENBQUM7SUFDckMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJhc2VDb21tYW5kIH0gZnJvbSBcIi4uL2xpYi9iYXNlLWNvbW1hbmQuanNcIjtcbmltcG9ydCB7IGxvZ291dCB9IGZyb20gXCIuLi9saWIvYXV0aC5qc1wiO1xuaW1wb3J0IHsgc3VjY2VzcywgaW5mbyB9IGZyb20gXCIuLi9saWIvb3V0cHV0LmpzXCI7XG5pbXBvcnQgeyBpc0F1dGhlbnRpY2F0ZWQgfSBmcm9tIFwiLi4vbGliL2NvbmZpZy5qc1wiO1xuXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBMb2dvdXQgZXh0ZW5kcyBCYXNlQ29tbWFuZCB7XG4gIHN0YXRpYyBkZXNjcmlwdGlvbiA9IFwiTG9nIG91dCBvZiBTZW5kbHlcIjtcblxuICBzdGF0aWMgZXhhbXBsZXMgPSBbXCI8JT0gY29uZmlnLmJpbiAlPiBsb2dvdXRcIl07XG5cbiAgc3RhdGljIGZsYWdzID0ge1xuICAgIC4uLkJhc2VDb21tYW5kLmJhc2VGbGFncyxcbiAgfTtcblxuICBhc3luYyBydW4oKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgaWYgKCFpc0F1dGhlbnRpY2F0ZWQoKSkge1xuICAgICAgaW5mbyhcIk5vdCBjdXJyZW50bHkgbG9nZ2VkIGluXCIpO1xuICAgICAgcmV0dXJuO1xuICAgIH1cblxuICAgIGxvZ291dCgpO1xuICAgIHN1Y2Nlc3MoXCJMb2dnZWQgb3V0IHN1Y2Nlc3NmdWxseVwiKTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/trigger.d.ts

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

@@ -0,0 +1,61 @@
+import { Args } from "@oclif/core";
+import { AuthenticatedCommand } from "../lib/base-command.js";
+import { apiClient } from "../lib/api-client.js";
+import { success, error } from "../lib/output.js";
+const VALID_EVENT_TYPES = [
+    "message.sent",
+    "message.delivered",
+    "message.failed",
+    "message.bounced",
+    "message.received",
+];
+export default class Trigger extends AuthenticatedCommand {
+    static description = "Trigger a test webhook event. Sends a synthetic event to your active CLI listener.";
+    static examples = [
+        "<%= config.bin %> trigger message.delivered",
+        "<%= config.bin %> trigger message.failed",
+        "<%= config.bin %> trigger message.sent",
+    ];
+    static args = {
+        event: Args.string({
+            description: "Event type to trigger",
+            required: true,
+            options: VALID_EVENT_TYPES,
+        }),
+    };
+    static flags = {
+        ...AuthenticatedCommand.baseFlags,
+    };
+    async run() {
+        const { args } = await this.parse(Trigger);
+        const eventType = args.event;
+        if (!VALID_EVENT_TYPES.includes(eventType)) {
+            error(`Invalid event type: ${eventType}`, {
+                hint: `Valid types: ${VALID_EVENT_TYPES.join(", ")}`,
+            });
+            this.exit(1);
+        }
+        try {
+            const response = await apiClient.post(`/api/cli/trigger/${eventType}`, {});
+            if (response.success) {
+                success(response.message);
+            }
+            else {
+                error("Failed to trigger event");
+                this.exit(1);
+            }
+        }
+        catch (err) {
+            if (err.message?.includes("No active CLI listeners")) {
+                error("No active CLI listeners", {
+                    hint: "Run 'sendly webhooks listen' in another terminal first",
+                });
+            }
+            else {
+                throw err;
+            }
+            this.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -5,16 +5,17 @@ export default class WebhooksListen extends AuthenticatedCommand {
     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;
+    private ws;
+    private sessionId;
+    private secret;
     run(): Promise<void>;
-    private pollEvents;
+    private connectWebSocket;
+    private handleEvent;
+    private verifySignature;
     private displayEvent;
     private forwardEvent;
-    private generateSignature;
     private cleanup;
 }

package/dist/commands/webhooks/listen.js

@@ -1,10 +1,11 @@
 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 localtunnel from "localtunnel";
+import { error, info, warn, colors, spinner, } from "../../lib/output.js";
+import WebSocket from "ws";
+import * as crypto from "node:crypto";
 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 description = "Listen for webhooks locally. Receives events in real-time via WebSocket and forwards them to your local server.";
     static examples = [
         "<%= config.bin %> webhooks listen",
         "<%= config.bin %> webhooks listen --forward http://localhost:3000/webhook",
@@ -22,97 +23,116 @@ export default class WebhooksListen extends AuthenticatedCommand {
             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;
+    ws = null;
+    sessionId = null;
+    secret = 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`,
+            const response = await apiClient.post("/api/cli/listen/start", {
                 events,
                 forwardUrl: flags.forward,
             });
-            this.webhookId = webhookResponse.id;
-            const secret = webhookResponse.secret;
-            // Display connection info
+            this.sessionId = response.sessionId;
+            this.secret = response.secret;
+            spin.succeed("Listener registered");
             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(`  ${colors.primary(response.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..."));
+            const spin2 = spinner("Connecting to Sendly...");
+            spin2.start();
+            await this.connectWebSocket(response.wsUrl, flags.forward);
+            spin2.succeed("Connected");
+            console.log();
+            console.log(colors.bold("Waiting for events... (Ctrl+C to quit)"));
             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();
+            const cleanup = async () => {
+                console.log();
+                info("Shutting down...");
+                await 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);
+            };
+            process.on("SIGINT", cleanup);
+            process.on("SIGTERM", cleanup);
+            await new Promise(() => { });
         }
         catch (err) {
             spin.fail("Failed to start listener");
             throw err;
         }
     }
-    async pollEvents(forwardUrl, secret) {
-        // Poll for events at regular intervals
-        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);
+    connectWebSocket(wsUrl, forwardUrl) {
+        return new Promise((resolve, reject) => {
+            this.ws = new WebSocket(wsUrl);
+            const timeout = setTimeout(() => {
+                reject(new Error("WebSocket connection timeout"));
+            }, 30000);
+            this.ws.on("open", () => {
+                clearTimeout(timeout);
+            });
+            this.ws.on("message", async (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    if (message.type === "cli_connected") {
+                        resolve();
+                        return;
+                    }
+                    if (message.type === "webhook_event" && message.event) {
+                        await this.handleEvent(message, forwardUrl);
+                    }
                 }
-            }
-            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(() => { });
+                catch (err) {
+                    console.error("Failed to parse WebSocket message:", err);
+                }
+            });
+            this.ws.on("close", (code, reason) => {
+                if (code !== 1000) {
+                    warn(`WebSocket disconnected: ${reason || code}`);
+                }
+            });
+            this.ws.on("error", (err) => {
+                clearTimeout(timeout);
+                error(`WebSocket error: ${err.message}`);
+                reject(err);
+            });
+        });
+    }
+    async handleEvent(message, forwardUrl) {
+        const event = message.event;
+        const timestamp = message.timestamp;
+        const signature = message.signature;
+        this.displayEvent(event);
+        if (this.verifySignature(event, timestamp, signature)) {
+            await this.forwardEvent(forwardUrl, event, timestamp, signature);
+        }
+        else {
+            console.log(`  ${colors.error("✗")} Signature verification failed`);
+            console.log();
+        }
+    }
+    verifySignature(event, timestamp, signature) {
+        if (!this.secret)
+            return false;
+        const payload = JSON.stringify(event);
+        const signedPayload = `${timestamp}.${payload}`;
+        const expectedSignature = `sha256=${crypto
+            .createHmac("sha256", this.secret)
+            .update(signedPayload, "utf8")
+            .digest("hex")}`;
+        return signature === expectedSignature;
     }
     displayEvent(event) {
         const timestamp = new Date(event.created * 1000).toLocaleTimeString();
@@ -123,28 +143,29 @@ export default class WebhooksListen extends AuthenticatedCommand {
         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;
+        const data = event.data?.object;
+        if (data) {
+            const messageId = data.id;
+            const to = data.to;
             if (messageId) {
-                console.log(`  ${colors.dim("message_id:")} ${messageId}`);
+                console.log(`  ${colors.dim("id:")} ${messageId}`);
             }
             if (to) {
                 console.log(`  ${colors.dim("to:")} ${to}`);
             }
         }
-        console.log();
     }
-    async forwardEvent(forwardUrl, event, secret) {
+    async forwardEvent(forwardUrl, event, timestamp, signature) {
         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-Timestamp": timestamp.toString(),
                     "X-Sendly-Event": event.type,
+                    "X-Sendly-Event-Id": event.id,
                 },
                 body: payload,
             });
@@ -160,25 +181,14 @@ export default class WebhooksListen extends AuthenticatedCommand {
         }
         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();
+        if (this.ws) {
+            this.ws.close(1000, "Client shutdown");
+            this.ws = null;
         }
-        // Clean up temporary webhook
-        if (this.webhookId) {
+        if (this.sessionId) {
             try {
-                await apiClient.delete(`/api/cli/webhooks/listen/${this.webhookId}`);
+                await apiClient.delete(`/api/cli/listen/stop/${this.sessionId}`);
             }
             catch {
                 // Ignore cleanup errors
@@ -186,4 +196,4 @@ export default class WebhooksListen extends AuthenticatedCommand {
         }
     }
 }
-//# 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:\n        \"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(\n        `  ${colors.dim(\"Tunnel URL:\")}     ${colors.code(tunnelUrl)}`,\n      );\n      console.log(\n        `  ${colors.dim(\"Forwarding to:\")} ${colors.code(flags.forward)}`,\n      );\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(\n        colors.dim(\"Use this secret to verify webhook signatures in your app.\"),\n      );\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    // Poll for events at regular intervals\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 =\n        (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\n      .map((b) => b.toString(16).padStart(2, \"0\"))\n      .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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"listen.js","sourceRoot":"","sources":["../../../src/commands/webhooks/listen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAEL,KAAK,EACL,IAAI,EACJ,IAAI,EACJ,MAAM,EACN,OAAO,GACR,MAAM,qBAAqB,CAAC;AAE7B,OAAO,SAAS,MAAM,IAAI,CAAC;AAC3B,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AA+BtC,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,oBAAoB;IAC9D,MAAM,CAAC,WAAW,GAChB,iHAAiH,CAAC;IAEpH,MAAM,CAAC,QAAQ,GAAG;QAChB,mCAAmC;QACnC,2EAA2E;QAC3E,6EAA6E;KAC9E,CAAC;IAEF,MAAM,CAAC,KAAK,GAAG;QACb,GAAG,oBAAoB,CAAC,SAAS;QACjC,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC;YACpB,IAAI,EAAE,GAAG;YACT,WAAW,EAAE,gCAAgC;YAC7C,OAAO,EAAE,+BAA+B;SACzC,CAAC;QACF,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC;YACnB,IAAI,EAAE,GAAG;YACT,WAAW,EAAE,8CAA8C;YAC3D,OAAO,EAAE,+DAA+D;SACzE,CAAC;KACH,CAAC;IAEM,EAAE,GAAqB,IAAI,CAAC;IAC5B,SAAS,GAAkB,IAAI,CAAC;IAChC,MAAM,GAAkB,IAAI,CAAC;IAErC,KAAK,CAAC,GAAG;QACP,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;QACnD,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;QAE5D,MAAM,IAAI,GAAG,OAAO,CAAC,8BAA8B,CAAC,CAAC;QACrD,IAAI,CAAC,KAAK,EAAE,CAAC;QAEb,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,MAAM,SAAS,CAAC,IAAI,CACnC,uBAAuB,EACvB;gBACE,MAAM;gBACN,UAAU,EAAE,KAAK,CAAC,OAAO;aAC1B,CACF,CAAC;YAEF,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAC;YACpC,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;YAE9B,IAAI,CAAC,OAAO,CAAC,qBAAqB,CAAC,CAAC;YAEpC,OAAO,CAAC,GAAG,EAAE,CAAC;YACd,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC;YACpE,OAAO,CAAC,GAAG,EAAE,CAAC;YACd,OAAO,CAAC,GAAG,CACT,KAAK,MAAM,CAAC,GAAG,CAAC,gBAAgB,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAClE,CAAC;YACF,OAAO,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,WAAW,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACtE,OAAO,CAAC,GAAG,EAAE,CAAC;YACd,OAAO,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC,GAAG,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;YAClD,OAAO,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YACpD,OAAO,CAAC,GAAG,EAAE,CAAC;YACd,OAAO,CAAC,GAAG,CACT,MAAM,CAAC,GAAG,CAAC,2DAA2D,CAAC,CACxE,CAAC;YACF,OAAO,CAAC,GAAG,EAAE,CAAC;YAEd,MAAM,KAAK,GAAG,OAAO,CAAC,yBAAyB,CAAC,CAAC;YACjD,KAAK,CAAC,KAAK,EAAE,CAAC;YAEd,MAAM,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;YAE3D,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;YAC3B,OAAO,CAAC,GAAG,EAAE,CAAC;YACd,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC,CAAC;YACnE,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YACxC,OAAO,CAAC,GAAG,EAAE,CAAC;YAEd,MAAM,OAAO,GAAG,KAAK,IAAI,EAAE;gBACzB,OAAO,CAAC,GAAG,EAAE,CAAC;gBACd,IAAI,CAAC,kBAAkB,CAAC,CAAC;gBACzB,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;gBACrB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAClB,CAAC,CAAC;YAEF,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;YAC9B,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;YAE/B,MAAM,IAAI,OAAO,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;QAC9B,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,IAAI,CAAC,0BAA0B,CAAC,CAAC;YACtC,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC;IAEO,gBAAgB,CAAC,KAAa,EAAE,UAAkB;QACxD,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,CAAC,EAAE,GAAG,IAAI,SAAS,CAAC,KAAK,CAAC,CAAC;YAE/B,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC9B,MAAM,CAAC,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC,CAAC;YACpD,CAAC,EAAE,KAAK,CAAC,CAAC;YAEV,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE;gBACtB,YAAY,CAAC,OAAO,CAAC,CAAC;YACxB,CAAC,CAAC,CAAC;YAEH,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;gBACnC,IAAI,CAAC;oBACH,MAAM,OAAO,GAAqB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;oBAE9D,IAAI,OAAO,CAAC,IAAI,KAAK,eAAe,EAAE,CAAC;wBACrC,OAAO,EAAE,CAAC;wBACV,OAAO;oBACT,CAAC;oBAED,IAAI,OAAO,CAAC,IAAI,KAAK,eAAe,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;wBACtD,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;oBAC9C,CAAC;gBACH,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,OAAO,CAAC,KAAK,CAAC,oCAAoC,EAAE,GAAG,CAAC,CAAC;gBAC3D,CAAC;YACH,CAAC,CAAC,CAAC;YAEH,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE;gBACnC,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;oBAClB,IAAI,CAAC,2BAA2B,MAAM,IAAI,IAAI,EAAE,CAAC,CAAC;gBACpD,CAAC;YACH,CAAC,CAAC,CAAC;YAEH,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE;gBAC1B,YAAY,CAAC,OAAO,CAAC,CAAC;gBACtB,KAAK,CAAC,oBAAoB,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;gBACzC,MAAM,CAAC,GAAG,CAAC,CAAC;YACd,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,WAAW,CACvB,OAAyB,EACzB,UAAkB;QAElB,MAAM,KAAK,GAAG,OAAO,CAAC,KAAM,CAAC;QAC7B,MAAM,SAAS,GAAG,OAAO,CAAC,SAAU,CAAC;QACrC,MAAM,SAAS,GAAG,OAAO,CAAC,SAAU,CAAC;QAErC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QAEzB,IAAI,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC;YACtD,MAAM,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;QACnE,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,gCAAgC,CAAC,CAAC;YACpE,OAAO,CAAC,GAAG,EAAE,CAAC;QAChB,CAAC;IACH,CAAC;IAEO,eAAe,CACrB,KAAmB,EACnB,SAAiB,EACjB,SAAiB;QAEjB,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO,KAAK,CAAC;QAE/B,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACtC,MAAM,aAAa,GAAG,GAAG,SAAS,IAAI,OAAO,EAAE,CAAC;QAChD,MAAM,iBAAiB,GAAG,UAAU,MAAM;aACvC,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC;aACjC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC;aAC7B,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QAEnB,OAAO,SAAS,KAAK,iBAAiB,CAAC;IACzC,CAAC;IAEO,YAAY,CAAC,KAAmB;QACtC,MAAM,SAAS,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC,kBAAkB,EAAE,CAAC;QACtE,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC;QAE7B,IAAI,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC;QAC9B,IAAI,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC;YAAE,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC;QAClE,IAAI,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC;YAAE,WAAW,GAAG,MAAM,CAAC,KAAK,CAAC;QAE7D,OAAO,CAAC,GAAG,CACT,GAAG,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,WAAW,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CACzE,CAAC;QAEF,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC;QAChC,IAAI,IAAI,EAAE,CAAC;YACT,MAAM,SAAS,GAAG,IAAI,CAAC,EAAY,CAAC;YACpC,MAAM,EAAE,GAAG,IAAI,CAAC,EAAY,CAAC;YAC7B,IAAI,SAAS,EAAE,CAAC;gBACd,OAAO,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,SAAS,EAAE,CAAC,CAAC;YACrD,CAAC;YACD,IAAI,EAAE,EAAE,CAAC;gBACP,OAAO,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YAC9C,CAAC;QACH,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,YAAY,CACxB,UAAkB,EAClB,KAAmB,EACnB,SAAiB,EACjB,SAAiB;QAEjB,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YAEtC,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,UAAU,EAAE;gBACvC,MAAM,EAAE,MAAM;gBACd,OAAO,EAAE;oBACP,cAAc,EAAE,kBAAkB;oBAClC,oBAAoB,EAAE,SAAS;oBAC/B,oBAAoB,EAAE,SAAS,CAAC,QAAQ,EAAE;oBAC1C,gBAAgB,EAAE,KAAK,CAAC,IAAI;oBAC5B,mBAAmB,EAAE,KAAK,CAAC,EAAE;iBAC9B;gBACD,IAAI,EAAE,OAAO;aACd,CAAC,CAAC;YAEH,IAAI,QAAQ,CAAC,EAAE,EAAE,CAAC;gBAChB,OAAO,CAAC,GAAG,CACT,KAAK,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,iBAAiB,UAAU,KAAK,QAAQ,CAAC,MAAM,GAAG,CAC3E,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,OAAO,CAAC,GAAG,CACT,KAAK,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,oBAAoB,QAAQ,CAAC,MAAM,GAAG,CAC7D,CAAC;YACJ,CAAC;QACH,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,CAAC,GAAG,CACT,KAAK,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,mBAAoB,GAAa,CAAC,OAAO,EAAE,CAClE,CAAC;QACJ,CAAC;QACD,OAAO,CAAC,GAAG,EAAE,CAAC;IAChB,CAAC;IAEO,KAAK,CAAC,OAAO;QACnB,IAAI,IAAI,CAAC,EAAE,EAAE,CAAC;YACZ,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,iBAAiB,CAAC,CAAC;YACvC,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC;QACjB,CAAC;QAED,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,IAAI,CAAC;gBACH,MAAM,SAAS,CAAC,MAAM,CAAC,wBAAwB,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;YACnE,CAAC;YAAC,MAAM,CAAC;gBACP,wBAAwB;YAC1B,CAAC;QACH,CAAC;IACH,CAAC","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  spinner,\n} from \"../../lib/output.js\";\nimport { getConfigValue } from \"../../lib/config.js\";\nimport WebSocket from \"ws\";\nimport * as crypto from \"node:crypto\";\n\ninterface WebhookEvent {\n  id: string;\n  type: string;\n  api_version: string;\n  created: number;\n  livemode: boolean;\n  data: {\n    object: Record<string, unknown>;\n  };\n}\n\ninterface WebSocketMessage {\n  type: string;\n  timestamp?: number;\n  signature?: string;\n  event?: WebhookEvent;\n  sessionId?: string;\n  events?: string[];\n}\n\ninterface ListenStartResponse {\n  sessionId: string;\n  wsToken: string;\n  secret: string;\n  wsUrl: string;\n  events: string[];\n  forwardUrl: string;\n}\n\nexport default class WebhooksListen extends AuthenticatedCommand {\n  static description =\n    \"Listen for webhooks locally. Receives events in real-time via WebSocket and forwards them 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  };\n\n  private ws: WebSocket | null = null;\n  private sessionId: string | null = null;\n  private secret: string | null = null;\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(WebhooksListen);\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      const response = await apiClient.post<ListenStartResponse>(\n        \"/api/cli/listen/start\",\n        {\n          events,\n          forwardUrl: flags.forward,\n        },\n      );\n\n      this.sessionId = response.sessionId;\n      this.secret = response.secret;\n\n      spin.succeed(\"Listener registered\");\n\n      console.log();\n      console.log(colors.bold(colors.primary(\"Webhook listener ready!\")));\n      console.log();\n      console.log(\n        `  ${colors.dim(\"Forwarding to:\")} ${colors.code(flags.forward)}`,\n      );\n      console.log(`  ${colors.dim(\"Events:\")}        ${events.join(\", \")}`);\n      console.log();\n      console.log(`  ${colors.dim(\"Webhook Secret:\")}`);\n      console.log(`  ${colors.primary(response.secret)}`);\n      console.log();\n      console.log(\n        colors.dim(\"Use this secret to verify webhook signatures in your app.\"),\n      );\n      console.log();\n\n      const spin2 = spinner(\"Connecting to Sendly...\");\n      spin2.start();\n\n      await this.connectWebSocket(response.wsUrl, flags.forward);\n\n      spin2.succeed(\"Connected\");\n      console.log();\n      console.log(colors.bold(\"Waiting for events... (Ctrl+C to quit)\"));\n      console.log(colors.dim(\"─\".repeat(60)));\n      console.log();\n\n      const cleanup = async () => {\n        console.log();\n        info(\"Shutting down...\");\n        await this.cleanup();\n        process.exit(0);\n      };\n\n      process.on(\"SIGINT\", cleanup);\n      process.on(\"SIGTERM\", cleanup);\n\n      await new Promise(() => {});\n    } catch (err) {\n      spin.fail(\"Failed to start listener\");\n      throw err;\n    }\n  }\n\n  private connectWebSocket(wsUrl: string, forwardUrl: string): Promise<void> {\n    return new Promise((resolve, reject) => {\n      this.ws = new WebSocket(wsUrl);\n\n      const timeout = setTimeout(() => {\n        reject(new Error(\"WebSocket connection timeout\"));\n      }, 30000);\n\n      this.ws.on(\"open\", () => {\n        clearTimeout(timeout);\n      });\n\n      this.ws.on(\"message\", async (data) => {\n        try {\n          const message: WebSocketMessage = JSON.parse(data.toString());\n\n          if (message.type === \"cli_connected\") {\n            resolve();\n            return;\n          }\n\n          if (message.type === \"webhook_event\" && message.event) {\n            await this.handleEvent(message, forwardUrl);\n          }\n        } catch (err) {\n          console.error(\"Failed to parse WebSocket message:\", err);\n        }\n      });\n\n      this.ws.on(\"close\", (code, reason) => {\n        if (code !== 1000) {\n          warn(`WebSocket disconnected: ${reason || code}`);\n        }\n      });\n\n      this.ws.on(\"error\", (err) => {\n        clearTimeout(timeout);\n        error(`WebSocket error: ${err.message}`);\n        reject(err);\n      });\n    });\n  }\n\n  private async handleEvent(\n    message: WebSocketMessage,\n    forwardUrl: string,\n  ): Promise<void> {\n    const event = message.event!;\n    const timestamp = message.timestamp!;\n    const signature = message.signature!;\n\n    this.displayEvent(event);\n\n    if (this.verifySignature(event, timestamp, signature)) {\n      await this.forwardEvent(forwardUrl, event, timestamp, signature);\n    } else {\n      console.log(`  ${colors.error(\"✗\")} Signature verification failed`);\n      console.log();\n    }\n  }\n\n  private verifySignature(\n    event: WebhookEvent,\n    timestamp: number,\n    signature: string,\n  ): boolean {\n    if (!this.secret) return false;\n\n    const payload = JSON.stringify(event);\n    const signedPayload = `${timestamp}.${payload}`;\n    const expectedSignature = `sha256=${crypto\n      .createHmac(\"sha256\", this.secret)\n      .update(signedPayload, \"utf8\")\n      .digest(\"hex\")}`;\n\n    return signature === expectedSignature;\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    const data = event.data?.object;\n    if (data) {\n      const messageId = data.id as string;\n      const to = data.to as string;\n      if (messageId) {\n        console.log(`  ${colors.dim(\"id:\")} ${messageId}`);\n      }\n      if (to) {\n        console.log(`  ${colors.dim(\"to:\")} ${to}`);\n      }\n    }\n  }\n\n  private async forwardEvent(\n    forwardUrl: string,\n    event: WebhookEvent,\n    timestamp: number,\n    signature: string,\n  ): Promise<void> {\n    try {\n      const payload = JSON.stringify(event);\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-Timestamp\": timestamp.toString(),\n          \"X-Sendly-Event\": event.type,\n          \"X-Sendly-Event-Id\": event.id,\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 cleanup(): Promise<void> {\n    if (this.ws) {\n      this.ws.close(1000, \"Client shutdown\");\n      this.ws = null;\n    }\n\n    if (this.sessionId) {\n      try {\n        await apiClient.delete(`/api/cli/listen/stop/${this.sessionId}`);\n      } catch {\n        // Ignore cleanup errors\n      }\n    }\n  }\n}\n"]}

package/dist/lib/auth.js

@@ -92,7 +92,6 @@ export async function browserLogin() {
             });
             if (tokenResponse.ok) {
                 const tokens = (await tokenResponse.json());
-                spin.succeed("Logged in successfully!");
                 // Store tokens
                 setAuthTokens(tokens.accessToken, tokens.refreshToken, tokens.expiresIn, tokens.userId, tokens.email);
                 // Check if new user needs quick-start (only for CLI sessions)
@@ -184,4 +183,4 @@ export async function getAuthInfo() {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/lib/auth.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Authentication utilities for CLI\n * Handles browser-based login flow and API key authentication\n */\n\nimport open from \"open\";\nimport * as http from \"node:http\";\nimport * as crypto from \"node:crypto\";\nimport {\n  setAuthTokens,\n  setApiKey,\n  clearAuth,\n  getConfigValue,\n  isAuthenticated,\n  getAuthToken,\n} from \"./config.js\";\nimport { colors, spinner } from \"./output.js\";\n\nconst USER_CODE_LENGTH = 8;\nconst POLL_INTERVAL = 2000; // 2 seconds\nconst MAX_POLL_ATTEMPTS = 150; // 5 minutes max\n\nexport interface DeviceCodeResponse {\n  deviceCode: string;\n  userCode: string;\n  verificationUrl: string;\n  expiresIn: number;\n  interval: number;\n}\n\nexport interface TokenResponse {\n  accessToken: string;\n  refreshToken: string;\n  expiresIn: number;\n  userId: string;\n  email: string;\n}\n\n/**\n * Generate a long random device code for URL (session identifier)\n * This goes in the URL and identifies which CLI session is waiting\n */\nexport function generateDeviceCode(): string {\n  return crypto.randomBytes(16).toString(\"hex\"); // 32 chars, not guessable\n}\n\n/**\n * Generate a short human-readable user code for terminal display\n * This is what the user types to prove they have terminal access\n * Uses characters that are easy to read and type (no 0/O, 1/I/L confusion)\n */\nexport function generateUserCode(): string {\n  const chars = \"ABCDEFGHJKLMNPQRSTUVWXYZ23456789\"; // Exclude confusing chars\n  let code = \"\";\n  const bytes = crypto.randomBytes(USER_CODE_LENGTH);\n  for (let i = 0; i < USER_CODE_LENGTH; i++) {\n    code += chars[bytes[i] % chars.length];\n  }\n  return code;\n}\n\n/**\n * Start the browser-based login flow\n *\n * Security model:\n * - deviceCode: Long random token in URL, identifies CLI session (not secret)\n * - userCode: Short code shown ONLY in terminal, proves user has terminal access\n *\n * The userCode is NEVER in the URL - this is critical for security.\n * Anyone with the URL can't authorize without also seeing the terminal.\n */\nexport async function browserLogin(): Promise<TokenResponse> {\n  const baseUrl = getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n\n  // Generate TWO SEPARATE codes for security\n  const deviceCode = generateDeviceCode(); // Long random, goes in URL\n  const userCode = generateUserCode(); // Short readable, shown in terminal only\n\n  // Request device code registration from server\n  const response = await fetch(`${baseUrl}/api/cli/auth/device-code`, {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/json\" },\n    body: JSON.stringify({ deviceCode, userCode }), // Send both to server\n  });\n\n  if (!response.ok) {\n    const error = (await response.json().catch(() => ({}))) as {\n      message?: string;\n    };\n    throw new Error(error.message || \"Failed to initiate login\");\n  }\n\n  const data = (await response.json()) as DeviceCodeResponse;\n\n  // Format user code with hyphen for readability (e.g., \"ABCD-EFGH\")\n  const displayUserCode = `${userCode.slice(0, 4)}-${userCode.slice(4)}`;\n\n  // Display instructions to user\n  console.log();\n  console.log(colors.bold(\"Login to Sendly\"));\n  console.log();\n  console.log(`Open this URL in your browser:`);\n  console.log(colors.primary(`  ${data.verificationUrl}`));\n  console.log();\n  console.log(`And enter this code:`);\n  console.log(colors.bold(colors.primary(`  ${displayUserCode}`)));\n  console.log();\n\n  // Try to open browser automatically\n  try {\n    await open(data.verificationUrl);\n    console.log(colors.dim(\"Browser opened automatically\"));\n  } catch {\n    console.log(colors.dim(\"Please open the URL manually\"));\n  }\n\n  console.log();\n\n  // Poll for token\n  const spin = spinner(\"Waiting for authorization...\");\n  spin.start();\n\n  let attempts = 0;\n  while (attempts < MAX_POLL_ATTEMPTS) {\n    await sleep(data.interval * 1000 || POLL_INTERVAL);\n    attempts++;\n\n    try {\n      const tokenResponse = await fetch(`${baseUrl}/api/cli/auth/token`, {\n        method: \"POST\",\n        headers: { \"Content-Type\": \"application/json\" },\n        body: JSON.stringify({ deviceCode }),\n      });\n\n      if (tokenResponse.ok) {\n        const tokens = (await tokenResponse.json()) as TokenResponse;\n        spin.succeed(\"Logged in successfully!\");\n\n        // Store tokens\n        setAuthTokens(\n          tokens.accessToken,\n          tokens.refreshToken,\n          tokens.expiresIn,\n          tokens.userId,\n          tokens.email,\n        );\n\n        // Check if new user needs quick-start (only for CLI sessions)\n        if (tokens.accessToken.startsWith(\"cli_\")) {\n          const { shouldOfferQuickStart, offerQuickStart } =\n            await import(\"./onboarding.js\");\n\n          if (await shouldOfferQuickStart()) {\n            await offerQuickStart();\n          }\n        }\n\n        return tokens;\n      }\n\n      const errorData = (await tokenResponse.json().catch(() => ({}))) as {\n        error?: string;\n      };\n\n      if (errorData.error === \"authorization_pending\") {\n        // Still waiting, continue polling\n        continue;\n      }\n\n      if (errorData.error === \"expired_token\") {\n        spin.fail(\"Login request expired\");\n        process.exit(1);\n      }\n\n      if (errorData.error === \"access_denied\") {\n        spin.fail(\"Login was denied\");\n        process.exit(1);\n      }\n    } catch (error) {\n      // Network error, continue polling\n    }\n  }\n\n  spin.fail(\"Login timed out\");\n  process.exit(1);\n}\n\n/**\n * Login with an API key directly\n */\nexport async function apiKeyLogin(apiKey: string): Promise<void> {\n  const baseUrl = getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n\n  // Validate the API key with the server\n  const response = await fetch(`${baseUrl}/api/cli/auth/verify-key`, {\n    method: \"POST\",\n    headers: {\n      \"Content-Type\": \"application/json\",\n      Authorization: `Bearer ${apiKey}`,\n    },\n  });\n\n  if (!response.ok) {\n    const error = (await response.json().catch(() => ({}))) as {\n      message?: string;\n    };\n    throw new Error(error.message || \"Invalid API key\");\n  }\n\n  // Store the API key\n  setApiKey(apiKey);\n}\n\n/**\n * Logout - clear all stored credentials\n */\nexport function logout(): void {\n  clearAuth();\n}\n\n/**\n * Check if currently authenticated\n */\nexport function checkAuth(): boolean {\n  return isAuthenticated();\n}\n\n/**\n * Get current auth info for display\n */\nexport async function getAuthInfo(): Promise<{\n  authenticated: boolean;\n  email?: string;\n  userId?: string;\n  environment: string;\n  keyType?: string;\n}> {\n  const token = getAuthToken();\n  const email = getConfigValue(\"email\");\n  const userId = getConfigValue(\"userId\");\n  const apiKey = getConfigValue(\"apiKey\");\n  const environment = getConfigValue(\"environment\");\n\n  if (!token && !apiKey) {\n    return { authenticated: false, environment };\n  }\n\n  let keyType: string | undefined;\n  if (apiKey) {\n    keyType = apiKey.startsWith(\"sk_test_\") ? \"test\" : \"live\";\n  }\n\n  return {\n    authenticated: true,\n    email,\n    userId,\n    environment,\n    keyType,\n  };\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/lib/auth.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Authentication utilities for CLI\n * Handles browser-based login flow and API key authentication\n */\n\nimport open from \"open\";\nimport * as http from \"node:http\";\nimport * as crypto from \"node:crypto\";\nimport {\n  setAuthTokens,\n  setApiKey,\n  clearAuth,\n  getConfigValue,\n  isAuthenticated,\n  getAuthToken,\n} from \"./config.js\";\nimport { colors, spinner } from \"./output.js\";\n\nconst USER_CODE_LENGTH = 8;\nconst POLL_INTERVAL = 2000; // 2 seconds\nconst MAX_POLL_ATTEMPTS = 150; // 5 minutes max\n\nexport interface DeviceCodeResponse {\n  deviceCode: string;\n  userCode: string;\n  verificationUrl: string;\n  expiresIn: number;\n  interval: number;\n}\n\nexport interface TokenResponse {\n  accessToken: string;\n  refreshToken: string;\n  expiresIn: number;\n  userId: string;\n  email: string;\n}\n\n/**\n * Generate a long random device code for URL (session identifier)\n * This goes in the URL and identifies which CLI session is waiting\n */\nexport function generateDeviceCode(): string {\n  return crypto.randomBytes(16).toString(\"hex\"); // 32 chars, not guessable\n}\n\n/**\n * Generate a short human-readable user code for terminal display\n * This is what the user types to prove they have terminal access\n * Uses characters that are easy to read and type (no 0/O, 1/I/L confusion)\n */\nexport function generateUserCode(): string {\n  const chars = \"ABCDEFGHJKLMNPQRSTUVWXYZ23456789\"; // Exclude confusing chars\n  let code = \"\";\n  const bytes = crypto.randomBytes(USER_CODE_LENGTH);\n  for (let i = 0; i < USER_CODE_LENGTH; i++) {\n    code += chars[bytes[i] % chars.length];\n  }\n  return code;\n}\n\n/**\n * Start the browser-based login flow\n *\n * Security model:\n * - deviceCode: Long random token in URL, identifies CLI session (not secret)\n * - userCode: Short code shown ONLY in terminal, proves user has terminal access\n *\n * The userCode is NEVER in the URL - this is critical for security.\n * Anyone with the URL can't authorize without also seeing the terminal.\n */\nexport async function browserLogin(): Promise<TokenResponse> {\n  const baseUrl = getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n\n  // Generate TWO SEPARATE codes for security\n  const deviceCode = generateDeviceCode(); // Long random, goes in URL\n  const userCode = generateUserCode(); // Short readable, shown in terminal only\n\n  // Request device code registration from server\n  const response = await fetch(`${baseUrl}/api/cli/auth/device-code`, {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/json\" },\n    body: JSON.stringify({ deviceCode, userCode }), // Send both to server\n  });\n\n  if (!response.ok) {\n    const error = (await response.json().catch(() => ({}))) as {\n      message?: string;\n    };\n    throw new Error(error.message || \"Failed to initiate login\");\n  }\n\n  const data = (await response.json()) as DeviceCodeResponse;\n\n  // Format user code with hyphen for readability (e.g., \"ABCD-EFGH\")\n  const displayUserCode = `${userCode.slice(0, 4)}-${userCode.slice(4)}`;\n\n  // Display instructions to user\n  console.log();\n  console.log(colors.bold(\"Login to Sendly\"));\n  console.log();\n  console.log(`Open this URL in your browser:`);\n  console.log(colors.primary(`  ${data.verificationUrl}`));\n  console.log();\n  console.log(`And enter this code:`);\n  console.log(colors.bold(colors.primary(`  ${displayUserCode}`)));\n  console.log();\n\n  // Try to open browser automatically\n  try {\n    await open(data.verificationUrl);\n    console.log(colors.dim(\"Browser opened automatically\"));\n  } catch {\n    console.log(colors.dim(\"Please open the URL manually\"));\n  }\n\n  console.log();\n\n  // Poll for token\n  const spin = spinner(\"Waiting for authorization...\");\n  spin.start();\n\n  let attempts = 0;\n  while (attempts < MAX_POLL_ATTEMPTS) {\n    await sleep(data.interval * 1000 || POLL_INTERVAL);\n    attempts++;\n\n    try {\n      const tokenResponse = await fetch(`${baseUrl}/api/cli/auth/token`, {\n        method: \"POST\",\n        headers: { \"Content-Type\": \"application/json\" },\n        body: JSON.stringify({ deviceCode }),\n      });\n\n      if (tokenResponse.ok) {\n        const tokens = (await tokenResponse.json()) as TokenResponse;\n\n        // Store tokens\n        setAuthTokens(\n          tokens.accessToken,\n          tokens.refreshToken,\n          tokens.expiresIn,\n          tokens.userId,\n          tokens.email,\n        );\n\n        // Check if new user needs quick-start (only for CLI sessions)\n        if (tokens.accessToken.startsWith(\"cli_\")) {\n          const { shouldOfferQuickStart, offerQuickStart } =\n            await import(\"./onboarding.js\");\n\n          if (await shouldOfferQuickStart()) {\n            await offerQuickStart();\n          }\n        }\n\n        return tokens;\n      }\n\n      const errorData = (await tokenResponse.json().catch(() => ({}))) as {\n        error?: string;\n      };\n\n      if (errorData.error === \"authorization_pending\") {\n        // Still waiting, continue polling\n        continue;\n      }\n\n      if (errorData.error === \"expired_token\") {\n        spin.fail(\"Login request expired\");\n        process.exit(1);\n      }\n\n      if (errorData.error === \"access_denied\") {\n        spin.fail(\"Login was denied\");\n        process.exit(1);\n      }\n    } catch (error) {\n      // Network error, continue polling\n    }\n  }\n\n  spin.fail(\"Login timed out\");\n  process.exit(1);\n}\n\n/**\n * Login with an API key directly\n */\nexport async function apiKeyLogin(apiKey: string): Promise<void> {\n  const baseUrl = getConfigValue(\"baseUrl\") || \"https://sendly.live\";\n\n  // Validate the API key with the server\n  const response = await fetch(`${baseUrl}/api/cli/auth/verify-key`, {\n    method: \"POST\",\n    headers: {\n      \"Content-Type\": \"application/json\",\n      Authorization: `Bearer ${apiKey}`,\n    },\n  });\n\n  if (!response.ok) {\n    const error = (await response.json().catch(() => ({}))) as {\n      message?: string;\n    };\n    throw new Error(error.message || \"Invalid API key\");\n  }\n\n  // Store the API key\n  setApiKey(apiKey);\n}\n\n/**\n * Logout - clear all stored credentials\n */\nexport function logout(): void {\n  clearAuth();\n}\n\n/**\n * Check if currently authenticated\n */\nexport function checkAuth(): boolean {\n  return isAuthenticated();\n}\n\n/**\n * Get current auth info for display\n */\nexport async function getAuthInfo(): Promise<{\n  authenticated: boolean;\n  email?: string;\n  userId?: string;\n  environment: string;\n  keyType?: string;\n}> {\n  const token = getAuthToken();\n  const email = getConfigValue(\"email\");\n  const userId = getConfigValue(\"userId\");\n  const apiKey = getConfigValue(\"apiKey\");\n  const environment = getConfigValue(\"environment\");\n\n  if (!token && !apiKey) {\n    return { authenticated: false, environment };\n  }\n\n  let keyType: string | undefined;\n  if (apiKey) {\n    keyType = apiKey.startsWith(\"sk_test_\") ? \"test\" : \"live\";\n  }\n\n  return {\n    authenticated: true,\n    email,\n    userId,\n    environment,\n    keyType,\n  };\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n"]}

package/dist/lib/config.d.ts

@@ -9,6 +9,7 @@
  * - SENDLY_NO_COLOR: Disable colored output (any value)
  * - SENDLY_TIMEOUT: Request timeout in ms (default: 30000)
  * - SENDLY_MAX_RETRIES: Max retry attempts (default: 3)
+ * - SENDLY_CONFIG_KEY: Custom encryption key (for CI/CD)
  * - CI: Auto-detect CI mode (disables interactive prompts)
  */
 import Conf from "conf";