@sendly/cli 3.36.0 → 3.37.1

package/dist/commands/upgrade.js

@@ -1,67 +1,160 @@
 import { Command, Flags } from "@oclif/core";
 import { spawn } from "node:child_process";
 import { detectInstallPath, upgradeCommandFor, } from "../lib/detect-install-path.js";
-import { success, error, info } from "../lib/output.js";
+import { colors, success, error, info, spinner, divider, } from "../lib/output.js";
 /**
- * `sendly upgrade` — bring the CLI up to the latest version.
+ * `sendly upgrade` — bring the CLI up to the latest version with a guided,
+ * animated flow: an animated version check, a `vCURRENT → vLATEST` diff, and a
+ * success panel. The noisy package-manager output is hidden behind a spinner
+ * for Homebrew (which never needs sudo); for npm we keep inherited stdio so an
+ * auth/sudo prompt can never hang invisibly behind a spinner.
  *
- * Detects the install path (Homebrew vs npm-global vs unknown) and
- * executes the matching package-manager upgrade command. If the install
- * path is unknown we print both options for the user to pick.
+ * `--check` is a dry-run: it shows the detected install method and the command
+ * that would run, without changing anything.
  *
- * The `--check` flag does a dry-run: prints what would happen without
- * executing anything. Useful in restricted shells where we don't want
- * to trigger a brew/npm run accidentally.
- *
- * The unattended in-band update banner that prompts users to run this
- * comes from the `@oclif/plugin-warn-if-update-available` plugin wired
- * in package.json; this command is the companion action for that
- * banner.
+ * The unattended banner that nudges users to run this comes from the
+ * `@oclif/plugin-warn-if-update-available` plugin wired in package.json; this
+ * command is the companion action for that banner.
  */
+const REGISTRY_URL = "https://registry.npmjs.org/@sendly/cli";
+const CHANGELOG_URL = "https://sendly.live/docs/changelog";
+function bumpType(from, to) {
+    const a = from.split(".").map((n) => parseInt(n, 10));
+    const b = to.split(".").map((n) => parseInt(n, 10));
+    if (a.length < 3 || b.length < 3 || [...a, ...b].some(Number.isNaN))
+        return "";
+    if (b[0] > a[0])
+        return "major";
+    if (b[1] > a[1])
+        return "minor";
+    if (b[2] > a[2])
+        return "patch";
+    return "";
+}
+async function fetchLatest() {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 4000);
+        const res = await fetch(REGISTRY_URL, {
+            headers: { accept: "application/vnd.npm.install-v1+json" },
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        return body["dist-tags"]?.latest ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function runCaptured(command) {
+    return new Promise((resolve) => {
+        const [bin, ...args] = command.split(" ");
+        const child = spawn(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
+        let output = "";
+        child.stdout?.on("data", (d) => (output += d.toString()));
+        child.stderr?.on("data", (d) => (output += d.toString()));
+        child.on("error", (err) => resolve({ code: 1, output: err.message }));
+        child.on("exit", (code) => resolve({ code: code ?? 1, output }));
+    });
+}
+function runInherited(command) {
+    return new Promise((resolve) => {
+        const [bin, ...args] = command.split(" ");
+        const child = spawn(bin, args, { stdio: "inherit" });
+        child.on("error", () => resolve(1));
+        child.on("exit", (code) => resolve(code ?? 1));
+    });
+}
 export default class Upgrade extends Command {
-    static description = "Upgrade Sendly CLI to the latest version using the package manager that installed it (Homebrew or npm).";
+    static description = "Upgrade the Sendly CLI to the latest version with a guided, animated flow.";
     static examples = [
         "<%= config.bin %> upgrade",
         "<%= config.bin %> upgrade --check",
     ];
     static flags = {
         check: Flags.boolean({
-            description: "Print the upgrade command for your install path without executing it",
+            description: "Show what would happen without changing anything",
             default: false,
         }),
     };
     async run() {
         const { flags } = await this.parse(Upgrade);
+        const current = this.config.version;
+        divider();
+        console.log(`  ${colors.highlight("⚡ Sendly CLI")}  ${colors.dim("upgrade")}`);
+        divider();
+        const spin = spinner("Checking for the latest version...").start();
+        const latest = await fetchLatest();
+        if (latest && latest === current) {
+            spin.succeed(`You're on the latest version ${colors.success.bold("v" + current)}`);
+            divider();
+            return;
+        }
+        if (latest) {
+            const kind = bumpType(current, latest);
+            spin.succeed(`Update available${kind ? " " + colors.dim(`(${kind})`) : ""}`);
+            console.log(`  ${colors.dim("v" + current)}  ${colors.primary("→")}  ${colors.success.bold("v" + latest)}`);
+            divider();
+        }
+        else {
+            spin.succeed("Ready to upgrade");
+        }
         const installPath = detectInstallPath();
         const command = upgradeCommandFor(installPath);
         if (installPath === "unknown") {
-            info("Can't detect how you installed the Sendly CLI. Pick the matching command:\n" +
-                "  • Homebrew: brew upgrade sendly\n" +
-                "  • npm:      npm install -g @sendly/cli@latest");
+            info("Can't detect how the CLI was installed. Run whichever matches:\n" +
+                `  ${colors.code("brew upgrade sendly")}                ${colors.dim("(Homebrew)")}\n` +
+                `  ${colors.code("npm install -g @sendly/cli@latest")}  ${colors.dim("(npm)")}`);
             return;
         }
         if (flags.check) {
-            info(`Detected install path: ${installPath}\nWould run: ${command}`);
+            info(`Install method: ${colors.bold(installPath)}\n` +
+                `Would run:      ${colors.code(command)}`);
             return;
         }
-        info(`Upgrading via ${installPath}: ${command}`);
-        const [bin, ...args] = command.split(" ");
-        const child = spawn(bin, args, { stdio: "inherit" });
-        await new Promise((resolve) => {
-            child.on("exit", (code) => {
-                if (code === 0) {
-                    success("Upgrade complete. Run `sendly --version` to confirm the new version.");
-                }
-                else {
-                    error(`Upgrade command exited with code ${code}. Try running \`${command}\` manually.`);
-                }
-                resolve();
-            });
-            child.on("error", (err) => {
-                error(`Failed to execute upgrade command: ${err.message}. Try running \`${command}\` manually.`);
-                resolve();
-            });
-        });
+        const via = installPath === "homebrew" ? "Homebrew" : "npm";
+        const target = latest ? ` to ${colors.success("v" + latest)}` : "";
+        if (installPath === "homebrew") {
+            // Homebrew never needs sudo, so it's safe to hide its output behind a
+            // spinner for a clean, animated upgrade.
+            const upSpin = spinner(`Upgrading via ${via}${target}...`).start();
+            const { code, output } = await runCaptured(command);
+            if (code === 0) {
+                upSpin.stop();
+                this.renderSuccess(via, latest);
+            }
+            else {
+                upSpin.fail(`Upgrade failed via ${via}`);
+                const tail = output.trim().split("\n").slice(-6).join("\n");
+                if (tail)
+                    console.log(colors.dim(tail));
+                error(`Try running it yourself: ${colors.code(command)}`);
+            }
+            return;
+        }
+        // npm: keep inherited stdio so any auth/sudo prompt stays visible.
+        info(`Upgrading via ${via}${target}`);
+        console.log(colors.dim(`  ${command}`));
+        divider();
+        const code = await runInherited(command);
+        if (code === 0) {
+            this.renderSuccess(via, latest);
+        }
+        else {
+            error(`Upgrade command exited with code ${code}. Try running it yourself: ${colors.code(command)}`);
+        }
+    }
+    renderSuccess(via, latest) {
+        success(latest
+            ? `Upgraded to ${colors.success.bold("v" + latest)} via ${via}`
+            : `Upgrade complete via ${via}`);
+        divider();
+        info(`What's new: ${colors.code(CHANGELOG_URL)}`);
+        info("Run `sendly --version` to confirm.");
+        divider();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upgrade.js","sourceRoot":"","sources":["../../src/commands/upgrade.ts"],"names":[],"mappings":"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","sourcesContent":["import { Command, Flags } from \"@oclif/core\";\nimport { spawn } from \"node:child_process\";\nimport {\n  detectInstallPath,\n  upgradeCommandFor,\n} from \"../lib/detect-install-path.js\";\nimport {\n  colors,\n  success,\n  error,\n  info,\n  spinner,\n  divider,\n} from \"../lib/output.js\";\n\n/**\n * `sendly upgrade` — bring the CLI up to the latest version with a guided,\n * animated flow: an animated version check, a `vCURRENT → vLATEST` diff, and a\n * success panel. The noisy package-manager output is hidden behind a spinner\n * for Homebrew (which never needs sudo); for npm we keep inherited stdio so an\n * auth/sudo prompt can never hang invisibly behind a spinner.\n *\n * `--check` is a dry-run: it shows the detected install method and the command\n * that would run, without changing anything.\n *\n * The unattended banner that nudges users to run this comes from the\n * `@oclif/plugin-warn-if-update-available` plugin wired in package.json; this\n * command is the companion action for that banner.\n */\n\nconst REGISTRY_URL = \"https://registry.npmjs.org/@sendly/cli\";\nconst CHANGELOG_URL = \"https://sendly.live/docs/changelog\";\n\nfunction bumpType(from: string, to: string): \"major\" | \"minor\" | \"patch\" | \"\" {\n  const a = from.split(\".\").map((n) => parseInt(n, 10));\n  const b = to.split(\".\").map((n) => parseInt(n, 10));\n  if (a.length < 3 || b.length < 3 || [...a, ...b].some(Number.isNaN)) return \"\";\n  if (b[0] > a[0]) return \"major\";\n  if (b[1] > a[1]) return \"minor\";\n  if (b[2] > a[2]) return \"patch\";\n  return \"\";\n}\n\nasync function fetchLatest(): Promise<string | null> {\n  try {\n    const controller = new AbortController();\n    const timer = setTimeout(() => controller.abort(), 4000);\n    const res = await fetch(REGISTRY_URL, {\n      headers: { accept: \"application/vnd.npm.install-v1+json\" },\n      signal: controller.signal,\n    });\n    clearTimeout(timer);\n    if (!res.ok) return null;\n    const body = (await res.json()) as {\n      \"dist-tags\"?: { latest?: string };\n    };\n    return body[\"dist-tags\"]?.latest ?? null;\n  } catch {\n    return null;\n  }\n}\n\nfunction runCaptured(\n  command: string,\n): Promise<{ code: number; output: string }> {\n  return new Promise((resolve) => {\n    const [bin, ...args] = command.split(\" \");\n    const child = spawn(bin, args, { stdio: [\"ignore\", \"pipe\", \"pipe\"] });\n    let output = \"\";\n    child.stdout?.on(\"data\", (d) => (output += d.toString()));\n    child.stderr?.on(\"data\", (d) => (output += d.toString()));\n    child.on(\"error\", (err) => resolve({ code: 1, output: err.message }));\n    child.on(\"exit\", (code) => resolve({ code: code ?? 1, output }));\n  });\n}\n\nfunction runInherited(command: string): Promise<number> {\n  return new Promise((resolve) => {\n    const [bin, ...args] = command.split(\" \");\n    const child = spawn(bin, args, { stdio: \"inherit\" });\n    child.on(\"error\", () => resolve(1));\n    child.on(\"exit\", (code) => resolve(code ?? 1));\n  });\n}\n\nexport default class Upgrade extends Command {\n  static description =\n    \"Upgrade the Sendly CLI to the latest version with a guided, animated flow.\";\n\n  static examples = [\n    \"<%= config.bin %> upgrade\",\n    \"<%= config.bin %> upgrade --check\",\n  ];\n\n  static flags = {\n    check: Flags.boolean({\n      description: \"Show what would happen without changing anything\",\n      default: false,\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(Upgrade);\n    const current = this.config.version;\n\n    divider();\n    console.log(\n      `  ${colors.highlight(\"⚡ Sendly CLI\")}  ${colors.dim(\"upgrade\")}`,\n    );\n    divider();\n\n    const spin = spinner(\"Checking for the latest version...\").start();\n    const latest = await fetchLatest();\n\n    if (latest && latest === current) {\n      spin.succeed(\n        `You're on the latest version ${colors.success.bold(\"v\" + current)}`,\n      );\n      divider();\n      return;\n    }\n\n    if (latest) {\n      const kind = bumpType(current, latest);\n      spin.succeed(\n        `Update available${kind ? \" \" + colors.dim(`(${kind})`) : \"\"}`,\n      );\n      console.log(\n        `  ${colors.dim(\"v\" + current)}  ${colors.primary(\"→\")}  ${colors.success.bold(\"v\" + latest)}`,\n      );\n      divider();\n    } else {\n      spin.succeed(\"Ready to upgrade\");\n    }\n\n    const installPath = detectInstallPath();\n    const command = upgradeCommandFor(installPath);\n\n    if (installPath === \"unknown\") {\n      info(\n        \"Can't detect how the CLI was installed. Run whichever matches:\\n\" +\n          `  ${colors.code(\"brew upgrade sendly\")}                ${colors.dim(\"(Homebrew)\")}\\n` +\n          `  ${colors.code(\"npm install -g @sendly/cli@latest\")}  ${colors.dim(\"(npm)\")}`,\n      );\n      return;\n    }\n\n    if (flags.check) {\n      info(\n        `Install method: ${colors.bold(installPath)}\\n` +\n          `Would run:      ${colors.code(command)}`,\n      );\n      return;\n    }\n\n    const via = installPath === \"homebrew\" ? \"Homebrew\" : \"npm\";\n    const target = latest ? ` to ${colors.success(\"v\" + latest)}` : \"\";\n\n    if (installPath === \"homebrew\") {\n      // Homebrew never needs sudo, so it's safe to hide its output behind a\n      // spinner for a clean, animated upgrade.\n      const upSpin = spinner(`Upgrading via ${via}${target}...`).start();\n      const { code, output } = await runCaptured(command);\n      if (code === 0) {\n        upSpin.stop();\n        this.renderSuccess(via, latest);\n      } else {\n        upSpin.fail(`Upgrade failed via ${via}`);\n        const tail = output.trim().split(\"\\n\").slice(-6).join(\"\\n\");\n        if (tail) console.log(colors.dim(tail));\n        error(`Try running it yourself: ${colors.code(command)}`);\n      }\n      return;\n    }\n\n    // npm: keep inherited stdio so any auth/sudo prompt stays visible.\n    info(`Upgrading via ${via}${target}`);\n    console.log(colors.dim(`  ${command}`));\n    divider();\n    const code = await runInherited(command);\n    if (code === 0) {\n      this.renderSuccess(via, latest);\n    } else {\n      error(\n        `Upgrade command exited with code ${code}. Try running it yourself: ${colors.code(command)}`,\n      );\n    }\n  }\n\n  private renderSuccess(via: string, latest: string | null): void {\n    success(\n      latest\n        ? `Upgraded to ${colors.success.bold(\"v\" + latest)} via ${via}`\n        : `Upgrade complete via ${via}`,\n    );\n    divider();\n    info(`What's new: ${colors.code(CHANGELOG_URL)}`);\n    info(\"Run `sendly --version` to confirm.\");\n    divider();\n  }\n}\n"]}

package/dist/commands/webhooks/listen.js

@@ -21,7 +21,7 @@ export default class WebhooksListen extends AuthenticatedCommand {
         events: Flags.string({
             char: "e",
             description: "Comma-separated list of events to listen for. Default subscribes to all message.* and contact.* / contacts.* events so nothing is missed during local dev.",
-            default: "message.sent,message.delivered,message.failed,message.bounced,message.retrying,message.received,message.opt_out,message.opt_in,contact.auto_flagged,contact.marked_valid,contacts.lookup_completed,contacts.bulk_marked_valid",
+            default: "message.sent,message.delivered,message.failed,message.bounced,message.retrying,message.received,message.opt_out,message.opt_in,contact.auto_flagged,contact.marked_valid,contacts.lookup_completed,contacts.bulk_marked_valid,brand.verified,brand.failed,campaign.approved,campaign.rejected,campaign.suspended,assignment.confirmed,assignment.failed,port.completed,port_out.requested,port_out.completed,port_out.rejected,port_out.cancelled,number.activated,number.failed,number.requirements_required,number.released",
         }),
     };
     ws = null;
@@ -208,4 +208,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":"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,EACT,4JAA4J;YAC9J,OAAO,EACL,+NAA+N;SAClO,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;QAEnD,IAAI,CAAC;YACH,IAAI,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACzB,CAAC;QAAC,MAAM,CAAC;YACP,IAAI,CAAC,KAAK,CAAC,wBAAwB,KAAK,CAAC,OAAO,8DAA8D,CAAC,CAAC;QAClH,CAAC;QAED,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,IAAI,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC;YAAE,WAAW,GAAG,MAAM,CAAC,KAAK,CAAC;QAC9F,IAAI,SAAS,CAAC,QAAQ,CAAC,UAAU,CAAC;YAAE,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC;QAEjE,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,MAAM,OAAO,GAAI,IAAY,CAAC,QAA8B,CAAC;YAC7D,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;YACD,IAAI,OAAO,EAAE,CAAC;gBACZ,OAAO,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,OAAO,EAAE,CAAC,CAAC;YACtD,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:\n        \"Comma-separated list of events to listen for. Default subscribes to all message.* and contact.* / contacts.* events so nothing is missed during local dev.\",\n      default:\n        \"message.sent,message.delivered,message.failed,message.bounced,message.retrying,message.received,message.opt_out,message.opt_in,contact.auto_flagged,contact.marked_valid,contacts.lookup_completed,contacts.bulk_marked_valid\",\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\n    try {\n      new URL(flags.forward);\n    } catch {\n      this.error(`Invalid forward URL: ${flags.forward}. Must be a valid URL (e.g., http://localhost:3000/webhook).`);\n    }\n\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\") || eventType.includes(\"bounced\")) statusColor = colors.error;\n    if (eventType.includes(\"retrying\")) statusColor = colors.warning;\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      const batchId = (data as any).batch_id as string | undefined;\n      if (messageId) {\n        console.log(`  ${colors.dim(\"id:\")} ${messageId}`);\n      }\n      if (to) {\n        console.log(`  ${colors.dim(\"to:\")} ${to}`);\n      }\n      if (batchId) {\n        console.log(`  ${colors.dim(\"batch:\")} ${batchId}`);\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"]}
+//# 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  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:\n        \"Comma-separated list of events to listen for. Default subscribes to all message.* and contact.* / contacts.* events so nothing is missed during local dev.\",\n      default:\n        \"message.sent,message.delivered,message.failed,message.bounced,message.retrying,message.received,message.opt_out,message.opt_in,contact.auto_flagged,contact.marked_valid,contacts.lookup_completed,contacts.bulk_marked_valid,brand.verified,brand.failed,campaign.approved,campaign.rejected,campaign.suspended,assignment.confirmed,assignment.failed,port.completed,port_out.requested,port_out.completed,port_out.rejected,port_out.cancelled,number.activated,number.failed,number.requirements_required,number.released\",\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\n    try {\n      new URL(flags.forward);\n    } catch {\n      this.error(`Invalid forward URL: ${flags.forward}. Must be a valid URL (e.g., http://localhost:3000/webhook).`);\n    }\n\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\") || eventType.includes(\"bounced\")) statusColor = colors.error;\n    if (eventType.includes(\"retrying\")) statusColor = colors.warning;\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      const batchId = (data as any).batch_id as string | undefined;\n      if (messageId) {\n        console.log(`  ${colors.dim(\"id:\")} ${messageId}`);\n      }\n      if (to) {\n        console.log(`  ${colors.dim(\"to:\")} ${to}`);\n      }\n      if (batchId) {\n        console.log(`  ${colors.dim(\"batch:\")} ${batchId}`);\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"]}