@hookstream/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1976 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command50 } from "commander";
+
+// src/output.ts
+import chalk from "chalk";
+var jsonMode = false;
+function setJsonMode(enabled) {
+  jsonMode = enabled;
+}
+function isJsonMode() {
+  return jsonMode;
+}
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function printTable(rows, columns) {
+  if (rows.length === 0) {
+    console.log(chalk.dim("  No results."));
+    return;
+  }
+  const widths = columns.map((col) => {
+    const maxData = rows.reduce((max, row) => Math.max(max, (row[col.key] || "").length), 0);
+    return col.width || Math.max(col.label.length, Math.min(maxData, 40));
+  });
+  const header = columns.map((col, i) => chalk.bold(col.label.padEnd(widths[i]))).join("  ");
+  console.log(header);
+  console.log(chalk.dim("\u2500".repeat(header.length)));
+  for (const row of rows) {
+    const line = columns.map((col, i) => {
+      const val = row[col.key] || "";
+      return val.length > widths[i] ? val.slice(0, widths[i] - 1) + "\u2026" : val.padEnd(widths[i]);
+    }).join("  ");
+    console.log(line);
+  }
+}
+function printSuccess(msg) {
+  console.log(chalk.green("\u2713") + " " + msg);
+}
+function printError(msg) {
+  console.error(chalk.red("Error:") + " " + msg);
+}
+function printKeyValue(pairs) {
+  const maxLabel = pairs.reduce((max, [label]) => Math.max(max, label.length), 0);
+  for (const [label, value] of pairs) {
+    console.log(`  ${chalk.dim(label.padEnd(maxLabel))}  ${value ?? chalk.dim("\u2014")}`);
+  }
+}
+function formatDate(iso) {
+  if (!iso) return "\u2014";
+  const d = new Date(iso);
+  return d.toLocaleString();
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function statusColor(status) {
+  switch (status) {
+    case "active":
+    case "verified":
+    case "unique":
+    case "received":
+      return chalk.green(status);
+    case "paused":
+    case "skipped":
+      return chalk.yellow(status);
+    case "disabled":
+    case "failed":
+    case "duplicate":
+    case "error":
+    case "dlq":
+      return chalk.red(status);
+    case "success":
+      return chalk.green(status);
+    case "timeout":
+      return chalk.yellow(status);
+    default:
+      return status;
+  }
+}
+
+// src/commands/login.ts
+import { createInterface } from "readline/promises";
+import { stdin, stdout } from "process";
+import { Command } from "commander";
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".config", "hookstream");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+function loadConfig() {
+  if (!existsSync(CONFIG_FILE)) return {};
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+}
+function clearConfig() {
+  if (existsSync(CONFIG_FILE)) {
+    unlinkSync(CONFIG_FILE);
+  }
+}
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://hookstream.io";
+var hookstreamClient = class {
+  apiKey;
+  baseUrl;
+  constructor(opts = {}) {
+    const config = loadConfig();
+    this.apiKey = opts.apiKey || process.env.HOOKSTREAM_API_KEY || config.api_key || "";
+    this.baseUrl = (opts.baseUrl || process.env.HOOKSTREAM_BASE_URL || config.base_url || DEFAULT_BASE_URL).replace(/\/$/, "");
+    if (!this.apiKey) {
+      throw new Error("Not authenticated. Run `hookstream login` or set HOOKSTREAM_API_KEY.");
+    }
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  getApiKeyPrefix() {
+    return this.apiKey.slice(0, 16) + "...";
+  }
+  async get(path) {
+    return this.request("GET", path);
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  async patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  async del(path) {
+    return this.request("DELETE", path);
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}/v1${path}`;
+    const headers = {
+      "X-API-Key": this.apiKey,
+      "Accept": "application/json"
+    };
+    if (body !== void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    const json = await res.json();
+    if (!res.ok) {
+      const err = json;
+      throw new Error(err.error || err.message || `HTTP ${res.status}`);
+    }
+    return json;
+  }
+};
+async function publicRequest(baseUrl, path, opts = {}) {
+  const url = `${baseUrl.replace(/\/$/, "")}${path}`;
+  return fetch(url, {
+    method: opts.method || "POST",
+    headers: opts.headers,
+    body: opts.body
+  });
+}
+
+// src/commands/login.ts
+var loginCommand = new Command("login").description("Authenticate with an API key").option("--api-key <key>", "API key (or enter interactively)").option("--base-url <url>", "Override base URL").action(async (opts) => {
+  let apiKey = opts.apiKey;
+  if (!apiKey) {
+    const rl = createInterface({ input: stdin, output: stdout });
+    apiKey = await rl.question("Enter your API key: ");
+    rl.close();
+  }
+  if (!apiKey || !apiKey.trim()) {
+    printError("API key cannot be empty.");
+    process.exit(1);
+  }
+  apiKey = apiKey.trim();
+  if (!/^hs_(live|test)_[a-f0-9]{64}$/.test(apiKey)) {
+    printError("Invalid API key format. Expected: hs_live_<64 hex> or hs_test_<64 hex>");
+    process.exit(1);
+  }
+  try {
+    const client = new hookstreamClient({ apiKey, baseUrl: opts.baseUrl });
+    await client.get("/sources");
+  } catch (err) {
+    printError(`Authentication failed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  const config = loadConfig();
+  config.api_key = apiKey;
+  if (opts.baseUrl) {
+    config.base_url = opts.baseUrl;
+  }
+  saveConfig(config);
+  if (isJsonMode()) {
+    printJson({ success: true, prefix: apiKey.slice(0, 16) + "..." });
+  } else {
+    printSuccess(`Logged in as ${apiKey.slice(0, 16)}...`);
+  }
+});
+
+// src/commands/logout.ts
+import { Command as Command2 } from "commander";
+var logoutCommand = new Command2("logout").description("Remove stored credentials").action(() => {
+  clearConfig();
+  if (isJsonMode()) {
+    printJson({ success: true });
+  } else {
+    printSuccess(`Logged out. Config removed from ${getConfigPath()}`);
+  }
+});
+
+// src/commands/whoami.ts
+import { Command as Command3 } from "commander";
+var whoamiCommand = new Command3("whoami").description("Show current authentication info").action(async () => {
+  const config = loadConfig();
+  if (!config.api_key) {
+    printError("Not logged in. Run `hookstream login`.");
+    process.exit(1);
+  }
+  try {
+    const client = new hookstreamClient();
+    const data = await client.get("/sources");
+    if (isJsonMode()) {
+      printJson({
+        api_key_prefix: client.getApiKeyPrefix(),
+        base_url: client.getBaseUrl(),
+        source_count: data.sources.length,
+        config_path: getConfigPath()
+      });
+    } else {
+      console.log();
+      printKeyValue([
+        ["API Key", client.getApiKeyPrefix()],
+        ["Base URL", client.getBaseUrl()],
+        ["Sources", String(data.sources.length)],
+        ["Config", getConfigPath()]
+      ]);
+      console.log();
+    }
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/sources/index.ts
+import { Command as Command9 } from "commander";
+
+// src/commands/sources/list.ts
+import { Command as Command4 } from "commander";
+var sourcesListCommand = new Command4("list").description("List all sources").option("--status <status>", "Filter by status (active, paused, disabled)").action(async (opts) => {
+  try {
+    const client = new hookstreamClient();
+    const params = new URLSearchParams();
+    if (opts.status) params.set("status", opts.status);
+    const qs = params.toString();
+    const data = await client.get(`/sources${qs ? `?${qs}` : ""}`);
+    if (isJsonMode()) {
+      printJson(data.sources);
+      return;
+    }
+    console.log();
+    printTable(
+      data.sources.map((s) => ({
+        id: s.id.slice(0, 12),
+        name: s.name,
+        slug: s.slug,
+        template: s.template || "custom",
+        status: statusColor(s.status),
+        events: String(s.event_count),
+        last_event: formatDate(s.last_event_at)
+      })),
+      [
+        { key: "id", label: "ID", width: 14 },
+        { key: "name", label: "Name", width: 20 },
+        { key: "slug", label: "Slug", width: 16 },
+        { key: "template", label: "Template", width: 12 },
+        { key: "status", label: "Status", width: 10 },
+        { key: "events", label: "Events", width: 8 },
+        { key: "last_event", label: "Last Event" }
+      ]
+    );
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/sources/create.ts
+import { Command as Command5 } from "commander";
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+var sourcesCreateCommand = new Command5("create").description("Create a new source").argument("<name>", "Source name").option("--slug <slug>", "URL slug (auto-generated from name if omitted)").option("--template <template>", "Provider template (stripe, github, shopify, etc.)").option("--org-id <id>", "Organization ID", "default").option("--env-id <id>", "Environment ID", "default").action(async (name, opts) => {
+  try {
+    const client = new hookstreamClient();
+    const slug = opts.slug || slugify(name);
+    const data = await client.post("/sources", {
+      org_id: opts.orgId,
+      env_id: opts.envId,
+      name,
+      slug,
+      template: opts.template || void 0
+    });
+    const s = data.source;
+    if (isJsonMode()) {
+      printJson(s);
+      return;
+    }
+    printSuccess(`Source created: ${s.name}`);
+    console.log();
+    printKeyValue([
+      ["ID", s.id],
+      ["Name", s.name],
+      ["Slug", s.slug],
+      ["Template", s.template || "custom"],
+      ["Ingest URL", `${client.getBaseUrl()}/v1/ingest/${s.id}`]
+    ]);
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/sources/get.ts
+import { Command as Command6 } from "commander";
+var sourcesGetCommand = new Command6("get").description("Get source details").argument("<id>", "Source ID").action(async (id) => {
+  try {
+    const client = new hookstreamClient();
+    const data = await client.get(`/sources/${id}`);
+    const s = data.source;
+    if (isJsonMode()) {
+      printJson(s);
+      return;
+    }
+    console.log();
+    printKeyValue([
+      ["ID", s.id],
+      ["Name", s.name],
+      ["Slug", s.slug],
+      ["Template", s.template || "custom"],
+      ["Status", statusColor(s.status)],
+      ["Events", String(s.event_count)],
+      ["Last Event", formatDate(s.last_event_at)],
+      ["Ingest URL", `${client.getBaseUrl()}/v1/ingest/${s.id}`],
+      ["Verification", s.verification_enabled ? `${s.verification_type} (${s.verification_header})` : "disabled"],
+      ["Dedup", s.dedup_enabled ? `${s.dedup_strategy} (${s.dedup_window_seconds}s)` : "disabled"],
+      ["Created", formatDate(s.created_at)],
+      ["Updated", formatDate(s.updated_at)]
+    ]);
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/sources/delete.ts
+import { createInterface as createInterface2 } from "readline/promises";
+import { stdin as stdin2, stdout as stdout2 } from "process";
+import { Command as Command7 } from "commander";
+var sourcesDeleteCommand = new Command7("delete").description("Delete a source").argument("<id>", "Source ID").option("-f, --force", "Skip confirmation prompt").action(async (id, opts) => {
+  try {
+    if (!opts.force) {
+      const rl = createInterface2({ input: stdin2, output: stdout2 });
+      const answer = await rl.question(`Delete source ${id}? This cannot be undone. [y/N] `);
+      rl.close();
+      if (answer.toLowerCase() !== "y") {
+        console.log("Cancelled.");
+        return;
+      }
+    }
+    const client = new hookstreamClient();
+    await client.del(`/sources/${id}`);
+    if (isJsonMode()) {
+      printJson({ success: true, id });
+    } else {
+      printSuccess(`Source ${id} deleted.`);
+    }
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/sources/templates.ts
+import { Command as Command8 } from "commander";
+var sourcesTemplatesCommand = new Command8("templates").description("List available source templates").action(async () => {
+  try {
+    const client = new hookstreamClient();
+    const data = await client.get("/sources/templates");
+    if (isJsonMode()) {
+      printJson(data.templates);
+      return;
+    }
+    console.log();
+    printTable(
+      data.templates.map((t) => ({
+        id: t.id,
+        name: t.name,
+        description: t.description,
+        verification: t.verification_type || "none"
+      })),
+      [
+        { key: "id", label: "ID", width: 14 },
+        { key: "name", label: "Name", width: 14 },
+        { key: "description", label: "Description", width: 36 },
+        { key: "verification", label: "Verification", width: 20 }
+      ]
+    );
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/sources/index.ts
+var sourcesCommand = new Command9("sources").description("Manage webhook sources").addCommand(sourcesListCommand).addCommand(sourcesCreateCommand).addCommand(sourcesGetCommand).addCommand(sourcesDeleteCommand).addCommand(sourcesTemplatesCommand);
+
+// src/commands/destinations/index.ts
+import { Command as Command16 } from "commander";
+
+// src/commands/destinations/list.ts
+import { Command as Command10 } from "commander";
+var destinationsListCommand = new Command10("list").description("List all destinations").option("--status <status>", "Filter by status (active, paused, disabled)").option("--type <type>", "Filter by type (http, aws_sqs, aws_s3, etc.)").action(async (opts) => {
+  try {
+    const client = new hookstreamClient();
+    const params = new URLSearchParams();
+    if (opts.status) params.set("status", opts.status);
+    if (opts.type) params.set("type", opts.type);
+    const qs = params.toString();
+    const data = await client.get(
+      `/destinations${qs ? `?${qs}` : ""}`
+    );
+    if (isJsonMode()) {
+      printJson(data.destinations);
+      return;
+    }
+    console.log();
+    printTable(
+      data.destinations.map((d) => ({
+        id: d.id.slice(0, 12),
+        name: d.name,
+        type: d.type || "http",
+        url: d.url.length > 35 ? d.url.slice(0, 34) + "\u2026" : d.url,
+        method: d.method,
+        status: statusColor(d.status),
+        deliveries: String(d.event_count),
+        last_delivery: formatDate(d.last_delivery_at)
+      })),
+      [
+        { key: "id", label: "ID", width: 14 },
+        { key: "name", label: "Name", width: 18 },
+        { key: "type", label: "Type", width: 12 },
+        { key: "url", label: "URL", width: 36 },
+        { key: "method", label: "Method", width: 8 },
+        { key: "status", label: "Status", width: 10 },
+        { key: "deliveries", label: "Delivered", width: 10 },
+        { key: "last_delivery", label: "Last Delivery" }
+      ]
+    );
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/destinations/create.ts
+import { Command as Command11 } from "commander";
+function slugify2(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+var destinationsCreateCommand = new Command11("create").description("Create a new destination").argument("<name>", "Destination name").option("--url <url>", "Destination URL (required for HTTP type)").option("--type <type>", "Destination type (http, aws_sqs, aws_s3, aws_eventbridge, gcp_pubsub, kafka, rabbitmq, websocket)", "http").option("--provider-config <json>", "Provider config JSON (required for non-HTTP types)").option("--method <method>", "HTTP method (GET, POST, PUT, PATCH, DELETE)", "POST").option("--header <headers...>", "Custom headers (key:value format)").option("--slug <slug>", "URL slug (auto-generated from name if omitted)").option("--auth-type <type>", "Auth type (none, api_key, bearer_token, basic)", "none").option("--timeout <ms>", "Timeout in milliseconds", "30000").option("--org-id <id>", "Organization ID", "default").option("--env-id <id>", "Environment ID", "default").action(async (name, opts) => {
+  try {
+    const client = new hookstreamClient();
+    const slug = opts.slug || slugify2(name);
+    const destType = opts.type || "http";
+    if (destType === "http" && !opts.url) {
+      printError("--url is required for HTTP destinations");
+      process.exit(1);
+    }
+    if (destType !== "http" && !opts.providerConfig) {
+      printError("--provider-config is required for non-HTTP destinations");
+      process.exit(1);
+    }
+    let headers;
+    if (opts.header) {
+      headers = {};
+      for (const h of opts.header) {
+        const colonIdx = h.indexOf(":");
+        if (colonIdx > 0) {
+          headers[h.slice(0, colonIdx).trim()] = h.slice(colonIdx + 1).trim();
+        }
+      }
+    }
+    let providerConfig;
+    if (opts.providerConfig) {
+      try {
+        providerConfig = JSON.parse(opts.providerConfig);
+      } catch {
+        printError("Invalid --provider-config JSON");
+        process.exit(1);
+      }
+    }
+    const body = {
+      org_id: opts.orgId,
+      env_id: opts.envId,
+      name,
+      slug,
+      type: destType,
+      timeout_ms: parseInt(opts.timeout, 10)
+    };
+    if (destType === "http") {
+      body.url = opts.url;
+      body.method = opts.method?.toUpperCase();
+      body.headers = headers;
+      body.auth_type = opts.authType;
+    } else {
+      body.provider_config = providerConfig;
+    }
+    const data = await client.post("/destinations", body);
+    const d = data.destination;
+    if (isJsonMode()) {
+      printJson(d);
+      return;
+    }
+    printSuccess(`Destination created: ${d.name}`);
+    console.log();
+    const entries = [
+      ["ID", d.id],
+      ["Name", d.name],
+      ["Type", d.type || "http"],
+      ["URL", d.url]
+    ];
+    if (destType === "http") {
+      entries.push(["Method", d.method]);
+      entries.push(["Auth", d.auth_type]);
+    }
+    entries.push(["Timeout", `${d.timeout_ms}ms`]);
+    printKeyValue(entries);
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/destinations/get.ts
+import { Command as Command12 } from "commander";
+var destinationsGetCommand = new Command12("get").description("Get destination details").argument("<id>", "Destination ID").action(async (id) => {
+  try {
+    const client = new hookstreamClient();
+    const data = await client.get(`/destinations/${id}`);
+    const d = data.destination;
+    if (isJsonMode()) {
+      printJson(d);
+      return;
+    }
+    const destType = d.type || "http";
+    console.log();
+    const entries = [
+      ["ID", d.id],
+      ["Name", d.name],
+      ["Type", destType],
+      ["Slug", d.slug],
+      ["URL", d.url]
+    ];
+    if (destType === "http") {
+      entries.push(["Method", d.method]);
+      entries.push(["Auth", d.auth_type]);
+    }
+    entries.push(
+      ["Status", statusColor(d.status)],
+      ["Timeout", `${d.timeout_ms}ms`],
+      ["Deliveries", String(d.event_count)],
+      ["Last Delivery", formatDate(d.last_delivery_at)],
+      ["Created", formatDate(d.created_at)],
+      ["Updated", formatDate(d.updated_at)]
+    );
+    printKeyValue(entries);
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/destinations/delete.ts
+import { createInterface as createInterface3 } from "readline/promises";
+import { stdin as stdin3, stdout as stdout3 } from "process";
+import { Command as Command13 } from "commander";
+var destinationsDeleteCommand = new Command13("delete").description("Delete a destination").argument("<id>", "Destination ID").option("-f, --force", "Skip confirmation prompt").action(async (id, opts) => {
+  try {
+    if (!opts.force) {
+      const rl = createInterface3({ input: stdin3, output: stdout3 });
+      const answer = await rl.question(`Delete destination ${id}? This cannot be undone. [y/N] `);
+      rl.close();
+      if (answer.toLowerCase() !== "y") {
+        console.log("Cancelled.");
+        return;
+      }
+    }
+    const client = new hookstreamClient();
+    await client.del(`/destinations/${id}`);
+    if (isJsonMode()) {
+      printJson({ success: true, id });
+    } else {
+      printSuccess(`Destination ${id} deleted.`);
+    }
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/destinations/circuit.ts
+import { Command as Command14 } from "commander";
+var destinationsCircuitCommand = new Command14("circuit").description("Show circuit breaker status for a destination").argument("<id>", "Destination ID").action(async (id) => {
+  try {
+    const client = new hookstreamClient();
+    const data = await client.get(`/destinations/${id}/circuit`);
+    if (isJsonMode()) {
+      printJson(data.circuit);
+      return;
+    }
+    const c = data.circuit;
+    console.log();
+    printKeyValue([
+      ["State", statusColor(c.circuit_state === "closed" ? "active" : c.circuit_state === "open" ? "error" : "paused").replace(/active|error|paused/, c.circuit_state)],
+      ["Failure count", String(c.failure_count)],
+      ["Opened at", c.opened_at ?? "\u2014"],
+      ["Pending retries", String(c.pending_retries)]
+    ]);
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/destinations/circuit-reset.ts
+import { Command as Command15 } from "commander";
+var destinationsCircuitResetCommand = new Command15("circuit-reset").description("Reset circuit breaker for a destination").argument("<id>", "Destination ID").action(async (id) => {
+  try {
+    const client = new hookstreamClient();
+    const data = await client.post(
+      `/destinations/${id}/circuit/reset`
+    );
+    if (isJsonMode()) {
+      printJson(data.circuit);
+      return;
+    }
+    printSuccess(`Circuit breaker reset for destination ${id}`);
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/destinations/index.ts
+var destinationsCommand = new Command16("destinations").description("Manage webhook destinations").addCommand(destinationsListCommand).addCommand(destinationsCreateCommand).addCommand(destinationsGetCommand).addCommand(destinationsDeleteCommand).addCommand(destinationsCircuitCommand).addCommand(destinationsCircuitResetCommand);
+
+// src/commands/connections/index.ts
+import { Command as Command21 } from "commander";
+
+// src/commands/connections/list.ts
+import { Command as Command17 } from "commander";
+var connectionsListCommand = new Command17("list").description("List all connections").option("--source <id>", "Filter by source ID").option("--destination <id>", "Filter by destination ID").option("--status <status>", "Filter by status (active, paused, disabled)").action(async (opts) => {
+  try {
+    const client = new hookstreamClient();
+    const params = new URLSearchParams();
+    if (opts.source) params.set("source_id", opts.source);
+    if (opts.destination) params.set("destination_id", opts.destination);
+    if (opts.status) params.set("status", opts.status);
+    const qs = params.toString();
+    const data = await client.get(
+      `/connections${qs ? `?${qs}` : ""}`
+    );
+    if (isJsonMode()) {
+      printJson(data.connections);
+      return;
+    }
+    console.log();
+    printTable(
+      data.connections.map((c) => ({
+        id: c.id.slice(0, 12),
+        name: c.name,
+        route: `${c.source_name || c.source_id.slice(0, 8)} \u2192 ${c.destination_name || c.destination_id.slice(0, 8)}`,
+        enabled: c.enabled ? "yes" : "no",
+        status: statusColor(c.status),
+        events: String(c.event_count),
+        last_event: formatDate(c.last_event_at)
+      })),
+      [
+        { key: "id", label: "ID", width: 14 },
+        { key: "name", label: "Name", width: 20 },
+        { key: "route", label: "Route", width: 30 },
+        { key: "enabled", label: "Enabled", width: 9 },
+        { key: "status", label: "Status", width: 10 },
+        { key: "events", label: "Events", width: 8 },
+        { key: "last_event", label: "Last Event" }
+      ]
+    );
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/connections/create.ts
+import { Command as Command18 } from "commander";
+var connectionsCreateCommand = new Command18("create").description("Create a new connection").argument("<name>", "Connection name").requiredOption("--source <id>", "Source ID").requiredOption("--destination <id>", "Destination ID").option("--filter <json>", "Filter rules as JSON array").option("--description <text>", "Connection description").option("--org-id <id>", "Organization ID", "default").option("--env-id <id>", "Environment ID", "default").action(async (name, opts) => {
+  try {
+    const client = new hookstreamClient();
+    let filterRules;
+    if (opts.filter) {
+      try {
+        filterRules = JSON.parse(opts.filter);
+        if (!Array.isArray(filterRules)) {
+          throw new Error("Filter rules must be a JSON array");
+        }
+      } catch (e) {
+        printError(`Invalid filter JSON: ${e instanceof Error ? e.message : String(e)}`);
+        process.exit(1);
+      }
+    }
+    const data = await client.post("/connections", {
+      org_id: opts.orgId,
+      env_id: opts.envId,
+      source_id: opts.source,
+      destination_id: opts.destination,
+      name,
+      description: opts.description,
+      filter_rules: filterRules
+    });
+    const conn = data.connection;
+    if (isJsonMode()) {
+      printJson(conn);
+      return;
+    }
+    printSuccess(`Connection created: ${conn.name}`);
+    console.log();
+    printKeyValue([
+      ["ID", conn.id],
+      ["Name", conn.name],
+      ["Source", conn.source_name || conn.source_id],
+      ["Destination", conn.destination_name || conn.destination_id],
+      ["Enabled", conn.enabled ? "yes" : "no"],
+      ["Filters", conn.filter_rules ? "configured" : "none"]
+    ]);
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/connections/get.ts
+import { Command as Command19 } from "commander";
+var connectionsGetCommand = new Command19("get").description("Get connection details").argument("<id>", "Connection ID").action(async (id) => {
+  try {
+    const client = new hookstreamClient();
+    const data = await client.get(`/connections/${id}`);
+    const conn = data.connection;
+    if (isJsonMode()) {
+      printJson(conn);
+      return;
+    }
+    console.log();
+    printKeyValue([
+      ["ID", conn.id],
+      ["Name", conn.name],
+      ["Description", conn.description || "\u2014"],
+      ["Source", conn.source_name || conn.source_id],
+      ["Destination", conn.destination_name || conn.destination_id],
+      ["Enabled", conn.enabled ? "yes" : "no"],
+      ["Status", statusColor(conn.status)],
+      ["Filters", conn.filter_rules ? JSON.stringify(JSON.parse(conn.filter_rules)) : "none"],
+      ["Events", String(conn.event_count)],
+      ["Last Event", formatDate(conn.last_event_at)],
+      ["Created", formatDate(conn.created_at)],
+      ["Updated", formatDate(conn.updated_at)]
+    ]);
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/connections/delete.ts
+import { createInterface as createInterface4 } from "readline/promises";
+import { stdin as stdin4, stdout as stdout4 } from "process";
+import { Command as Command20 } from "commander";
+var connectionsDeleteCommand = new Command20("delete").description("Delete a connection").argument("<id>", "Connection ID").option("-f, --force", "Skip confirmation prompt").action(async (id, opts) => {
+  try {
+    if (!opts.force) {
+      const rl = createInterface4({ input: stdin4, output: stdout4 });
+      const answer = await rl.question(`Delete connection ${id}? This cannot be undone. [y/N] `);
+      rl.close();
+      if (answer.toLowerCase() !== "y") {
+        console.log("Cancelled.");
+        return;
+      }
+    }
+    const client = new hookstreamClient();
+    await client.del(`/connections/${id}`);
+    if (isJsonMode()) {
+      printJson({ success: true, id });
+    } else {
+      printSuccess(`Connection ${id} deleted.`);
+    }
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/connections/index.ts
+var connectionsCommand = new Command21("connections").description("Manage source-to-destination connections").addCommand(connectionsListCommand).addCommand(connectionsCreateCommand).addCommand(connectionsGetCommand).addCommand(connectionsDeleteCommand);
+
+// src/commands/events/index.ts
+import { Command as Command25 } from "commander";
+
+// src/commands/events/list.ts
+import { Command as Command22 } from "commander";
+var eventsListCommand = new Command22("list").description("List events").option("--source <id>", "Filter by source ID").option("--status <status>", "Filter by status").option("--method <method>", "Filter by HTTP method").option("--verification <status>", "Filter by verification status").option("--limit <n>", "Number of events to show", "20").option("--cursor <cursor>", "Pagination cursor").action(async (opts) => {
+  try {
+    const client = new hookstreamClient();
+    const params = new URLSearchParams();
+    if (opts.source) params.set("source_id", opts.source);
+    if (opts.status) params.set("status", opts.status);
+    if (opts.method) params.set("method", opts.method.toUpperCase());
+    if (opts.verification) params.set("verification_status", opts.verification);
+    params.set("limit", opts.limit);
+    if (opts.cursor) params.set("cursor", opts.cursor);
+    const data = await client.get(`/events?${params}`);
+    if (isJsonMode()) {
+      printJson(data);
+      return;
+    }
+    console.log();
+    printTable(
+      data.events.map((e) => ({
+        id: e.id.slice(0, 12),
+        source: e.source_name || e.source_id.slice(0, 12),
+        method: e.method,
+        verification: statusColor(e.verification_status),
+        size: formatBytes(e.payload_size),
+        received: formatDate(e.received_at)
+      })),
+      [
+        { key: "id", label: "ID", width: 14 },
+        { key: "source", label: "Source", width: 16 },
+        { key: "method", label: "Method", width: 8 },
+        { key: "verification", label: "Verify", width: 12 },
+        { key: "size", label: "Size", width: 10 },
+        { key: "received", label: "Received" }
+      ]
+    );
+    const p = data.pagination;
+    console.log();
+    console.log(`  ${data.events.length} of ${p.total} events${p.has_more ? " (more available)" : ""}`);
+    if (p.next_cursor) {
+      console.log(`  Next: hookstream events list --cursor ${p.next_cursor}`);
+    }
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/events/get.ts
+import { Command as Command23 } from "commander";
+import chalk2 from "chalk";
+var eventsGetCommand = new Command23("get").description("Get event details").argument("<id>", "Event ID").action(async (id) => {
+  try {
+    const client = new hookstreamClient();
+    const data = await client.get(`/events/${id}`);
+    const e = data.event;
+    if (isJsonMode()) {
+      printJson(e);
+      return;
+    }
+    console.log();
+    printKeyValue([
+      ["ID", e.id],
+      ["Source", e.source_name ? `${e.source_name} (${e.source_id})` : e.source_id],
+      ["Method", e.method],
+      ["Content-Type", e.content_type],
+      ["Source IP", e.source_ip],
+      ["Size", formatBytes(e.payload_size)],
+      ["Status", statusColor(e.status)],
+      ["Verification", statusColor(e.verification_status)],
+      ["Dedup", statusColor(e.dedup_status)],
+      ["Received", formatDate(e.received_at)]
+    ]);
+    if (e.headers && Object.keys(e.headers).length > 0) {
+      console.log();
+      console.log(chalk2.bold("  Headers"));
+      for (const [key, val] of Object.entries(e.headers)) {
+        if (key.startsWith("cf-") || key.startsWith("x-real-") || key === "cdn-loop") continue;
+        console.log(`    ${chalk2.dim(key)}: ${val}`);
+      }
+    }
+    if (e.payload) {
+      console.log();
+      console.log(chalk2.bold("  Payload"));
+      try {
+        const parsed = JSON.parse(e.payload);
+        console.log(JSON.stringify(parsed, null, 2).split("\n").map((l) => `    ${l}`).join("\n"));
+      } catch {
+        const lines = e.payload.split("\n").slice(0, 50);
+        for (const line of lines) {
+          console.log(`    ${line}`);
+        }
+      }
+    }
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/events/replay.ts
+import { Command as Command24 } from "commander";
+import chalk3 from "chalk";
+var SKIP_HEADERS = /* @__PURE__ */ new Set([
+  "cf-connecting-ip",
+  "cf-ipcountry",
+  "cf-ray",
+  "cf-visitor",
+  "cf-warp-tag-id",
+  "cdn-loop",
+  "x-forwarded-for",
+  "x-forwarded-proto",
+  "x-real-ip",
+  "host",
+  "content-length",
+  "accept-encoding",
+  "connection",
+  "keep-alive"
+]);
+var eventsReplayCommand = new Command24("replay").description("Replay an event to a URL").argument("<id>", "Event ID").requiredOption("--to <url>", "Target URL to replay the event to").action(async (id, opts) => {
+  try {
+    const client = new hookstreamClient();
+    const data = await client.get(`/events/${id}`);
+    const e = data.event;
+    if (!e.payload) {
+      printError("Event has no payload to replay.");
+      process.exit(1);
+    }
+    const headers = { "Content-Type": e.content_type || "application/json" };
+    if (e.headers) {
+      for (const [key, val] of Object.entries(e.headers)) {
+        if (!SKIP_HEADERS.has(key.toLowerCase())) {
+          headers[key] = val;
+        }
+      }
+    }
+    const startMs = Date.now();
+    const res = await fetch(opts.to, {
+      method: e.method || "POST",
+      headers,
+      body: e.payload
+    });
+    const latencyMs = Date.now() - startMs;
+    const resBody = await res.text();
+    if (isJsonMode()) {
+      printJson({
+        event_id: id,
+        target: opts.to,
+        status: res.status,
+        latency_ms: latencyMs,
+        response_size: resBody.length
+      });
+      return;
+    }
+    const statusStr = res.ok ? chalk3.green(String(res.status)) : chalk3.red(String(res.status));
+    printSuccess(`Replayed event ${id.slice(0, 12)} to ${opts.to}`);
+    console.log();
+    printKeyValue([
+      ["Status", statusStr],
+      ["Latency", `${latencyMs}ms`],
+      ["Response", resBody.length > 200 ? resBody.slice(0, 200) + "..." : resBody || "(empty)"]
+    ]);
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/events/index.ts
+var eventsCommand = new Command25("events").description("Browse and replay events").addCommand(eventsListCommand).addCommand(eventsGetCommand).addCommand(eventsReplayCommand);
+
+// src/commands/deliveries/index.ts
+import { Command as Command30 } from "commander";
+
+// src/commands/deliveries/list.ts
+import { Command as Command26 } from "commander";
+var deliveriesListCommand = new Command26("list").description("List delivery attempts").option("--event <id>", "Filter by event ID").option("--connection <id>", "Filter by connection ID").option("--destination <id>", "Filter by destination ID").option("--status <status>", "Filter by status (success, failed, timeout, error, dlq)").option("--dlq", "Show only DLQ items").option("--limit <n>", "Max results", "20").action(async (opts) => {
+  try {
+    const client = new hookstreamClient();
+    const params = new URLSearchParams();
+    if (opts.event) params.set("event_id", opts.event);
+    if (opts.connection) params.set("connection_id", opts.connection);
+    if (opts.destination) params.set("destination_id", opts.destination);
+    if (opts.status) params.set("status", opts.status);
+    if (opts.dlq) params.set("is_dlq", "1");
+    params.set("limit", opts.limit);
+    const qs = params.toString();
+    const data = await client.get(
+      `/delivery-attempts${qs ? `?${qs}` : ""}`
+    );
+    if (isJsonMode()) {
+      printJson(data);
+      return;
+    }
+    console.log();
+    printTable(
+      data.delivery_attempts.map((a) => ({
+        id: a.id.slice(0, 12),
+        event: a.event_id.slice(0, 12),
+        destination: a.destination_name ?? a.destination_id.slice(0, 12),
+        status: statusColor(a.status),
+        code: a.response_status ? String(a.response_status) : "\u2014",
+        attempt: a.attempt_number ? `#${a.attempt_number}` : "#1",
+        duration: a.duration_ms !== null ? `${a.duration_ms}ms` : "\u2014",
+        created: formatDate(a.created_at)
+      })),
+      [
+        { key: "id", label: "ID", width: 14 },
+        { key: "event", label: "Event", width: 14 },
+        { key: "destination", label: "Destination", width: 20 },
+        { key: "status", label: "Status", width: 10 },
+        { key: "code", label: "Code", width: 6 },
+        { key: "attempt", label: "Att#", width: 6 },
+        { key: "duration", label: "Latency", width: 10 },
+        { key: "created", label: "Created" }
+      ]
+    );
+    if (data.pagination.has_more) {
+      console.log(`  ... and more (total: ${data.pagination.total})`);
+    }
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/deliveries/get.ts
+import { Command as Command27 } from "commander";
+var deliveriesGetCommand = new Command27("get").description("Get delivery attempt details").argument("<id>", "Delivery attempt ID").action(async (id) => {
+  try {
+    const client = new hookstreamClient();
+    const data = await client.get(`/delivery-attempts/${id}`);
+    const a = data.delivery_attempt;
+    if (isJsonMode()) {
+      printJson(a);
+      return;
+    }
+    console.log();
+    printKeyValue([
+      ["ID", a.id],
+      ["Event ID", a.event_id],
+      ["Connection ID", a.connection_id],
+      ["Connection", a.connection_name],
+      ["Destination ID", a.destination_id],
+      ["Destination", a.destination_name],
+      ["Status", statusColor(a.status)],
+      ["Attempt #", String(a.attempt_number ?? 1)],
+      ["Trigger", a.trigger_type ?? "auto"],
+      ["Request", `${a.request_method} ${a.request_url}`],
+      ["Response", a.response_status ? String(a.response_status) : "\u2014"],
+      ["Latency", a.duration_ms !== null ? `${a.duration_ms}ms` : "\u2014"],
+      ["Error", a.error],
+      ["DLQ", a.is_dlq ? "Yes" : "No"],
+      ["DLQ at", a.dlq_at ? formatDate(a.dlq_at) : null],
+      ["Next retry", a.next_retry_at ? formatDate(a.next_retry_at) : null],
+      ["Created", formatDate(a.created_at)]
+    ]);
+    if (a.response_body) {
+      console.log("\n  Response body:");
+      console.log("  " + a.response_body.slice(0, 500));
+    }
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/deliveries/retry.ts
+import { Command as Command28 } from "commander";
+var deliveriesRetryCommand = new Command28("retry").description("Retry a failed delivery attempt").argument("<id>", "Delivery attempt ID").action(async (id) => {
+  try {
+    const client = new hookstreamClient();
+    const data = await client.post(
+      `/delivery-attempts/${id}/retry`
+    );
+    if (isJsonMode()) {
+      printJson(data);
+      return;
+    }
+    const a = data.delivery_attempt;
+    printSuccess(`Retry triggered for attempt ${id}`);
+    console.log();
+    printKeyValue([
+      ["New Attempt ID", String(a.id ?? "\u2014")],
+      ["Status", statusColor(String(a.status ?? "\u2014"))],
+      ["Response", a.response_status ? String(a.response_status) : "\u2014"],
+      ["Latency", a.duration_ms !== null ? `${a.duration_ms}ms` : "\u2014"]
+    ]);
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/deliveries/dlq.ts
+import { Command as Command29 } from "commander";
+var deliveriesDlqCommand = new Command29("dlq").description("List dead-letter queue items").option("--destination <id>", "Filter by destination ID").option("--limit <n>", "Max results", "50").action(async (opts) => {
+  try {
+    const client = new hookstreamClient();
+    const params = new URLSearchParams();
+    params.set("is_dlq", "1");
+    if (opts.destination) params.set("destination_id", opts.destination);
+    params.set("limit", opts.limit);
+    const qs = params.toString();
+    const data = await client.get(
+      `/delivery-attempts?${qs}`
+    );
+    if (isJsonMode()) {
+      printJson(data);
+      return;
+    }
+    console.log();
+    if (data.delivery_attempts.length === 0) {
+      console.log("  No items in the dead-letter queue.");
+    } else {
+      printTable(
+        data.delivery_attempts.map((a) => ({
+          id: a.id.slice(0, 12),
+          event: a.event_id.slice(0, 12),
+          destination: a.destination_name ?? a.destination_id.slice(0, 12),
+          status: statusColor(a.status),
+          attempts: a.attempt_number ? String(a.attempt_number) : "1",
+          error: a.error ? a.error.length > 30 ? a.error.slice(0, 29) + "\u2026" : a.error : "\u2014",
+          dlq_at: formatDate(a.dlq_at)
+        })),
+        [
+          { key: "id", label: "ID", width: 14 },
+          { key: "event", label: "Event", width: 14 },
+          { key: "destination", label: "Destination", width: 20 },
+          { key: "status", label: "Status", width: 8 },
+          { key: "attempts", label: "Att#", width: 6 },
+          { key: "error", label: "Error", width: 30 },
+          { key: "dlq_at", label: "DLQ At" }
+        ]
+      );
+      if (data.pagination.has_more) {
+        console.log(`  ... and more (total: ${data.pagination.total})`);
+      }
+    }
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/deliveries/index.ts
+var deliveriesCommand = new Command30("deliveries").description("Manage delivery attempts").addCommand(deliveriesListCommand).addCommand(deliveriesGetCommand).addCommand(deliveriesRetryCommand).addCommand(deliveriesDlqCommand);
+
+// src/commands/metrics/index.ts
+import { Command as Command33 } from "commander";
+
+// src/commands/metrics/overview.ts
+import { Command as Command31 } from "commander";
+var metricsOverviewCommand = new Command31("overview").description("Show metrics overview").action(async () => {
+  try {
+    const client = new hookstreamClient();
+    const data = await client.get("/metrics/overview");
+    if (isJsonMode()) {
+      printJson(data);
+      return;
+    }
+    console.log();
+    printKeyValue([
+      ["Events Today", String(data.events_today)],
+      ["Events This Week", String(data.events_this_week)],
+      ["Active Sources", String(data.active_sources)],
+      ["Active Destinations", String(data.active_destinations)],
+      ["Deliveries Today", String(data.deliveries_today)],
+      ["Success Rate", `${data.success_rate_today}%`],
+      ["DLQ Count", String(data.dlq_count)]
+    ]);
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/metrics/volume.ts
+import { Command as Command32 } from "commander";
+import chalk4 from "chalk";
+var metricsVolumeCommand = new Command32("volume").description("Show event volume over time").option("--source <id>", "Filter by source ID").option("--after <iso>", "Start time (ISO 8601)").option("--before <iso>", "End time (ISO 8601)").option("--granularity <period>", "hour or day", "hour").action(async (opts) => {
+  try {
+    const client = new hookstreamClient();
+    const params = new URLSearchParams();
+    if (opts.source) params.set("source_id", opts.source);
+    if (opts.after) params.set("after", opts.after);
+    if (opts.before) params.set("before", opts.before);
+    params.set("granularity", opts.granularity);
+    if (!opts.after) {
+      params.set("after", new Date(Date.now() - 24 * 60 * 60 * 1e3).toISOString());
+    }
+    const qs = params.toString();
+    const data = await client.get(
+      `/metrics/volume${qs ? `?${qs}` : ""}`
+    );
+    if (isJsonMode()) {
+      printJson(data);
+      return;
+    }
+    if (data.series.length === 0) {
+      console.log(chalk4.dim("\n  No volume data for this time range.\n"));
+      return;
+    }
+    console.log();
+    printTable(
+      data.series.map((row) => ({
+        bucket: formatBucket(row.bucket, data.granularity),
+        source: row.source_name ?? row.source_id.slice(0, 12),
+        events: String(row.event_count),
+        bar: renderBar(row.event_count, Math.max(...data.series.map((r) => r.event_count)))
+      })),
+      [
+        { key: "bucket", label: "Time", width: 20 },
+        { key: "source", label: "Source", width: 20 },
+        { key: "events", label: "Events", width: 8 },
+        { key: "bar", label: "Volume", width: 20 }
+      ]
+    );
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+function formatBucket(bucket, granularity) {
+  const d = new Date(bucket);
+  if (granularity === "day") {
+    return d.toLocaleDateString(void 0, { month: "short", day: "numeric", year: "numeric" });
+  }
+  return d.toLocaleString(void 0, { month: "short", day: "numeric", hour: "2-digit", minute: "2-digit" });
+}
+function renderBar(value, max) {
+  if (max === 0) return "";
+  const width = 15;
+  const filled = Math.round(value / max * width);
+  return chalk4.cyan("\u2588".repeat(filled)) + chalk4.dim("\u2591".repeat(width - filled));
+}
+
+// src/commands/metrics/index.ts
+var metricsCommand = new Command33("metrics").description("View metrics and stats").addCommand(metricsOverviewCommand).addCommand(metricsVolumeCommand);
+
+// src/commands/test.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { Command as Command34 } from "commander";
+var DEFAULT_BASE_URL2 = "https://hookstream.io";
+var testCommand = new Command34("test").description("Send a test event to a source").argument("<source-id>", "Source ID to send the test event to").option("--payload <json>", "JSON payload string").option("--file <path>", "Read payload from a file").option("--method <method>", "HTTP method", "POST").option("-H, --header <header...>", "Headers in key:value format").option("--base-url <url>", "Override base URL").action(async (sourceId, opts) => {
+  const config = loadConfig();
+  const baseUrl = (opts.baseUrl || process.env.HOOKSTREAM_BASE_URL || config.base_url || DEFAULT_BASE_URL2).replace(/\/$/, "");
+  let payload;
+  if (opts.file) {
+    try {
+      payload = readFileSync2(opts.file, "utf-8");
+    } catch (err) {
+      printError(`Cannot read file: ${opts.file}`);
+      process.exit(1);
+    }
+  } else if (opts.payload) {
+    payload = opts.payload;
+  } else {
+    payload = JSON.stringify({ test: true, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  }
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (opts.header) {
+    for (const h of opts.header) {
+      const idx = h.indexOf(":");
+      if (idx === -1) {
+        printError(`Invalid header format: ${h} (expected key:value)`);
+        process.exit(1);
+      }
+      headers[h.slice(0, idx).trim()] = h.slice(idx + 1).trim();
+    }
+  }
+  try {
+    const startMs = Date.now();
+    const res = await publicRequest(baseUrl, `/v1/ingest/${sourceId}`, {
+      method: opts.method.toUpperCase(),
+      headers,
+      body: payload
+    });
+    const latencyMs = Date.now() - startMs;
+    const body = await res.json();
+    if (!res.ok) {
+      printError(body.error || `HTTP ${res.status}`);
+      process.exit(1);
+    }
+    const eventId = body.event_id;
+    if (isJsonMode()) {
+      const result = { ...body, latency_ms: latencyMs };
+      if (eventId && config.api_key) {
+        try {
+          const client = new hookstreamClient();
+          const detail = await client.get(`/events/${eventId}`);
+          result.event = detail.event;
+        } catch {
+        }
+      }
+      printJson(result);
+      return;
+    }
+    printSuccess(`Event sent to ${sourceId.slice(0, 12)}`);
+    console.log();
+    printKeyValue([
+      ["Event ID", eventId || "\u2014"],
+      ["Method", opts.method.toUpperCase()],
+      ["Latency", `${latencyMs}ms`],
+      ["Payload", `${payload.length} bytes`]
+    ]);
+    if (eventId && config.api_key) {
+      try {
+        await new Promise((r) => setTimeout(r, 500));
+        const client = new hookstreamClient();
+        const detail = await client.get(`/events/${eventId}`);
+        const e = detail.event;
+        printKeyValue([
+          ["Verification", statusColor(e.verification_status)],
+          ["Dedup", statusColor(e.dedup_status)]
+        ]);
+      } catch {
+      }
+    }
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/listen.ts
+import { Command as Command35 } from "commander";
+import chalk5 from "chalk";
+var DEFAULT_BASE_URL3 = "https://hookstream.io";
+var PROVIDER_SIGNATURES = [
+  { header: "stripe-signature", name: "Stripe" },
+  { header: "x-shopify-hmac-sha256", name: "Shopify" },
+  { header: "x-hub-signature-256", name: "GitHub" },
+  { header: "x-slack-signature", name: "Slack" },
+  { header: "x-twilio-signature", name: "Twilio" },
+  { header: "linear-signature", name: "Linear" },
+  { header: "paddle-signature", name: "Paddle" },
+  { header: "webhook-signature", name: "Webhooks" }
+];
+function detectProviderCli(headers) {
+  const lower = {};
+  for (const [k, v] of Object.entries(headers)) lower[k.toLowerCase()] = v;
+  for (const sig of PROVIDER_SIGNATURES) {
+    if (lower[sig.header]) return sig.name;
+  }
+  const ua = lower["user-agent"] ?? "";
+  if (/GitHub-Hookshot/i.test(ua)) return "GitHub";
+  if (/Stripe/i.test(ua)) return "Stripe";
+  if (/Shopify/i.test(ua)) return "Shopify";
+  if (/Slackbot/i.test(ua)) return "Slack";
+  return null;
+}
+function formatBytes2(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  return `${(bytes / 1024).toFixed(1)}KB`;
+}
+function truncate(str, max) {
+  if (str.length <= max) return str;
+  return str.slice(0, max - 3) + "...";
+}
+var listenCommand = new Command35("listen").description("Create a test URL and stream webhooks in real-time").option("--forward <url>", "Forward received webhooks to this URL").option("--full", "Show full payload (no truncation)").option("--base-url <url>", "Override base URL").action(async (opts) => {
+  const config = loadConfig();
+  const baseUrl = (opts.baseUrl || process.env.HOOKSTREAM_BASE_URL || config.base_url || DEFAULT_BASE_URL3).replace(/\/$/, "");
+  const jsonMode2 = isJsonMode();
+  try {
+    let connect2 = function() {
+      const ws = new WebSocket(wsFullUrl);
+      ws.addEventListener("open", () => {
+        reconnectAttempt = 0;
+      });
+      ws.addEventListener("message", async (event) => {
+        try {
+          const msg = JSON.parse(String(event.data));
+          if (msg.type === "event.received") {
+            const eventId = msg.data.id;
+            try {
+              const detailRes = await publicRequest(
+                baseUrl,
+                `/v1/test/sessions/${session.session_id}/events/${eventId}`,
+                { method: "GET" }
+              );
+              if (detailRes.ok) {
+                const detail = await detailRes.json();
+                if (jsonMode2) {
+                  console.log(JSON.stringify(detail));
+                  return;
+                }
+                const time = new Date(detail.received_at).toLocaleTimeString();
+                const method = detail.method;
+                const ct = detail.content_type ?? "unknown";
+                const size = formatBytes2(detail.payload_size);
+                const headers = (() => {
+                  try {
+                    return JSON.parse(detail.headers);
+                  } catch {
+                    return {};
+                  }
+                })();
+                const provider = detectProviderCli(headers);
+                const methodColor = method === "POST" ? chalk5.green : method === "GET" ? chalk5.blue : method === "PUT" ? chalk5.yellow : method === "DELETE" ? chalk5.red : chalk5.white;
+                console.log(
+                  `  ${chalk5.dim(`[${time}]`)} ${methodColor(method.padEnd(6))} ${chalk5.dim(ct.padEnd(24))} ${size.padEnd(8)} ${provider ? chalk5.magenta(`\u2190 ${provider}`) : ""}`
+                );
+                const payload = detail.payload ?? detail.payload_inline ?? "";
+                if (payload) {
+                  const display = opts.full ? payload : truncate(payload, 120);
+                  console.log(`  ${chalk5.dim("         ")} ${chalk5.dim(display)}`);
+                }
+              }
+            } catch {
+            }
+          }
+          if (msg.type === "forward.result") {
+            if (!jsonMode2) {
+              const status = msg.data.status;
+              const latency = msg.data.latency_ms;
+              const color = status >= 200 && status < 300 ? chalk5.green : chalk5.red;
+              console.log(
+                `  ${chalk5.dim("         ")} ${chalk5.dim("\u2192 Forward:")} ${color(String(status))} ${chalk5.dim(`${latency}ms`)}`
+              );
+            }
+          }
+        } catch {
+        }
+      });
+      ws.addEventListener("close", () => {
+        if (reconnectAttempt < maxReconnect) {
+          reconnectAttempt++;
+          const delay = Math.min(1e3 * Math.pow(2, reconnectAttempt), 3e4);
+          setTimeout(connect2, delay);
+        }
+      });
+      ws.addEventListener("error", () => {
+      });
+      const shutdown = () => {
+        ws.close();
+        if (!jsonMode2) {
+          console.log();
+          console.log(
+            chalk5.dim(`  Session active for 14 days at ${baseUrl.replace(/https:\/\/hookstream\.\w+\.workers\.dev/, "https://hookstream.io")}/test/${session.session_id}`)
+          );
+          console.log();
+        }
+        process.exit(0);
+      };
+      process.on("SIGINT", shutdown);
+      process.on("SIGTERM", shutdown);
+    };
+    var connect = connect2;
+    const createRes = await publicRequest(baseUrl, "/v1/test/sessions", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: "{}"
+    });
+    if (!createRes.ok) {
+      const err = await createRes.json();
+      printError(err.error ?? `HTTP ${createRes.status}`);
+      process.exit(1);
+    }
+    const session = await createRes.json();
+    if (!jsonMode2) {
+      console.log();
+      console.log(chalk5.bold.magenta("  hookstream Webhook Listener"));
+      console.log();
+      console.log(`  ${chalk5.dim("URL:")}       ${chalk5.cyan(session.url)}`);
+      console.log(`  ${chalk5.dim("Inspector:")} ${chalk5.cyan(`${baseUrl.replace(/https:\/\/hookstream\.\w+\.workers\.dev/, "https://hookstream.io")}/test/${session.session_id}`)}`);
+      console.log(`  ${chalk5.dim("Expires:")}   ${new Date(session.expires_at).toLocaleDateString()} (14 days)`);
+      console.log(`  ${chalk5.dim("Limit:")}     ${session.request_limit} requests`);
+      console.log();
+    }
+    if (opts.forward) {
+      try {
+        await publicRequest(baseUrl, `/v1/test/sessions/${session.session_id}/forwarding`, {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ url: opts.forward })
+        });
+        if (!jsonMode2) {
+          console.log(`  ${chalk5.dim("Forward:")}   ${chalk5.yellow(opts.forward)}`);
+          console.log();
+        }
+      } catch {
+        if (!jsonMode2) {
+          console.log(chalk5.yellow("  Warning: Could not configure forwarding"));
+          console.log();
+        }
+      }
+    }
+    if (!jsonMode2) {
+      console.log(chalk5.dim("  Listening... (Ctrl+C to stop)"));
+      console.log();
+    }
+    const wsUrl = baseUrl.replace("https://", "wss://").replace("http://", "ws://");
+    const wsFullUrl = `${wsUrl}/v1/ws/test/${session.session_id}`;
+    let reconnectAttempt = 0;
+    const maxReconnect = 10;
+    connect2();
+    await new Promise(() => {
+    });
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/topics/index.ts
+import { Command as Command43 } from "commander";
+
+// src/commands/topics/list.ts
+import { Command as Command36 } from "commander";
+var topicsListCommand = new Command36("list").description("List all topics").option("--status <status>", "Filter by status (active, paused)").action(async (opts) => {
+  try {
+    const client = new hookstreamClient();
+    const params = new URLSearchParams();
+    if (opts.status) params.set("status", opts.status);
+    const qs = params.toString();
+    const data = await client.get(`/topics${qs ? `?${qs}` : ""}`);
+    if (isJsonMode()) {
+      printJson(data.topics);
+      return;
+    }
+    console.log();
+    printTable(
+      data.topics.map((t) => ({
+        id: t.id.slice(0, 12),
+        name: t.name,
+        slug: t.slug,
+        status: statusColor(t.status),
+        created: formatDate(t.created_at)
+      })),
+      [
+        { key: "id", label: "ID", width: 14 },
+        { key: "name", label: "Name", width: 24 },
+        { key: "slug", label: "Slug", width: 20 },
+        { key: "status", label: "Status", width: 10 },
+        { key: "created", label: "Created" }
+      ]
+    );
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/topics/create.ts
+import { Command as Command37 } from "commander";
+function slugify3(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+var topicsCreateCommand = new Command37("create").description("Create a new topic").argument("<name>", "Topic name").option("--slug <slug>", "URL slug (auto-generated from name if omitted)").option("--description <desc>", "Topic description").action(async (name, opts) => {
+  try {
+    const client = new hookstreamClient();
+    const slug = opts.slug || slugify3(name);
+    const data = await client.post("/topics", {
+      name,
+      slug,
+      description: opts.description || void 0
+    });
+    const t = data.topic;
+    if (isJsonMode()) {
+      printJson(t);
+      return;
+    }
+    printSuccess(`Topic created: ${t.name}`);
+    console.log();
+    printKeyValue([
+      ["ID", t.id],
+      ["Name", t.name],
+      ["Slug", t.slug],
+      ["Description", t.description],
+      ["Status", t.status]
+    ]);
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/topics/get.ts
+import { Command as Command38 } from "commander";
+var topicsGetCommand = new Command38("get").description("Get topic details").argument("<id>", "Topic ID").action(async (id) => {
+  try {
+    const client = new hookstreamClient();
+    const data = await client.get(`/topics/${id}`);
+    const t = data.topic;
+    if (isJsonMode()) {
+      printJson(data);
+      return;
+    }
+    console.log();
+    printKeyValue([
+      ["ID", t.id],
+      ["Name", t.name],
+      ["Slug", t.slug],
+      ["Description", t.description],
+      ["Status", statusColor(t.status)],
+      ["Created", formatDate(t.created_at)],
+      ["Updated", formatDate(t.updated_at)]
+    ]);
+    if (data.subscriptions && data.subscriptions.length > 0) {
+      console.log();
+      console.log("  Subscriptions:");
+      console.log();
+      printTable(
+        data.subscriptions.map((s) => ({
+          id: s.id.slice(0, 12),
+          destination: s.destination_name || s.destination_id.slice(0, 12),
+          filter: s.filter_rules ? "yes" : "\u2014",
+          transform: s.transform_expression ? "yes" : "\u2014",
+          created: formatDate(s.created_at)
+        })),
+        [
+          { key: "id", label: "Sub ID", width: 14 },
+          { key: "destination", label: "Destination", width: 20 },
+          { key: "filter", label: "Filter", width: 8 },
+          { key: "transform", label: "Transform", width: 10 },
+          { key: "created", label: "Created" }
+        ]
+      );
+    }
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/topics/delete.ts
+import { createInterface as createInterface5 } from "readline/promises";
+import { stdin as stdin5, stdout as stdout5 } from "process";
+import { Command as Command39 } from "commander";
+var topicsDeleteCommand = new Command39("delete").description("Delete a topic").argument("<id>", "Topic ID").option("-f, --force", "Skip confirmation prompt").action(async (id, opts) => {
+  try {
+    if (!opts.force) {
+      const rl = createInterface5({ input: stdin5, output: stdout5 });
+      const answer = await rl.question(`Delete topic ${id}? This cannot be undone. [y/N] `);
+      rl.close();
+      if (answer.toLowerCase() !== "y") {
+        console.log("Cancelled.");
+        return;
+      }
+    }
+    const client = new hookstreamClient();
+    await client.del(`/topics/${id}`);
+    if (isJsonMode()) {
+      printJson({ success: true, id });
+    } else {
+      printSuccess(`Topic ${id} deleted.`);
+    }
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/topics/subscribe.ts
+import { Command as Command40 } from "commander";
+var topicsSubscribeCommand = new Command40("subscribe").description("Subscribe a destination to a topic").argument("<topic-id>", "Topic ID").argument("<destination-id>", "Destination ID").option("--filter <json>", "Filter rules as JSON").option("--transform <expr>", "JSONata transform expression").action(async (topicId, destinationId, opts) => {
+  try {
+    const client = new hookstreamClient();
+    const body = {
+      destination_id: destinationId
+    };
+    if (opts.filter) {
+      body.filter_rules = JSON.parse(opts.filter);
+    }
+    if (opts.transform) {
+      body.transform_expression = opts.transform;
+    }
+    const data = await client.post(
+      `/topics/${topicId}/subscriptions`,
+      body
+    );
+    const s = data.subscription;
+    if (isJsonMode()) {
+      printJson(s);
+      return;
+    }
+    printSuccess(`Subscription created`);
+    console.log();
+    printKeyValue([
+      ["Subscription ID", s.id],
+      ["Topic ID", s.topic_id],
+      ["Destination ID", s.destination_id],
+      ["Filter", s.filter_rules || "none"],
+      ["Transform", s.transform_expression || "none"]
+    ]);
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/topics/unsubscribe.ts
+import { Command as Command41 } from "commander";
+var topicsUnsubscribeCommand = new Command41("unsubscribe").description("Remove a subscription from a topic").argument("<topic-id>", "Topic ID").argument("<subscription-id>", "Subscription ID").action(async (topicId, subscriptionId) => {
+  try {
+    const client = new hookstreamClient();
+    await client.del(`/topics/${topicId}/subscriptions/${subscriptionId}`);
+    if (isJsonMode()) {
+      printJson({ success: true, topic_id: topicId, subscription_id: subscriptionId });
+    } else {
+      printSuccess(`Subscription ${subscriptionId} removed from topic ${topicId}.`);
+    }
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/topics/publish.ts
+import { Command as Command42 } from "commander";
+var topicsPublishCommand = new Command42("publish").description("Publish an event to a topic").argument("<slug>", "Topic slug").requiredOption("--data <json>", "Event payload as JSON").action(async (slug, opts) => {
+  try {
+    const client = new hookstreamClient();
+    const payload = JSON.parse(opts.data);
+    const data = await client.post(
+      `/topics/${slug}/publish`,
+      payload
+    );
+    if (isJsonMode()) {
+      printJson(data);
+      return;
+    }
+    printSuccess(`Event published to topic "${slug}"`);
+    console.log(`  Event ID:    ${data.event_id}`);
+    console.log(`  Deliveries:  ${data.deliveries}`);
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/topics/index.ts
+var topicsCommand = new Command43("topics").description("Manage topics and pub/sub").addCommand(topicsListCommand).addCommand(topicsCreateCommand).addCommand(topicsGetCommand).addCommand(topicsDeleteCommand).addCommand(topicsSubscribeCommand).addCommand(topicsUnsubscribeCommand).addCommand(topicsPublishCommand);
+
+// src/commands/replay/index.ts
+import { Command as Command46 } from "commander";
+
+// src/commands/replay/create.ts
+import { Command as Command44 } from "commander";
+var replayCreateCommand = new Command44("create").description("Create an event replay job").requiredOption("--destination <id>", "Destination ID to replay events to").requiredOption("--from <iso>", "Start time (ISO 8601)").requiredOption("--to <iso>", "End time (ISO 8601)").option("--source <id>", "Filter by source ID").option("--rate-limit <n>", "Max events per second", parseInt).option("--max-events <n>", "Maximum events to replay", parseInt).action(async (opts) => {
+  try {
+    const client = new hookstreamClient();
+    const body = {
+      destination_id: opts.destination,
+      from: opts.from,
+      to: opts.to
+    };
+    if (opts.source) body.source_id = opts.source;
+    if (opts.rateLimit) body.rate_limit = opts.rateLimit;
+    if (opts.maxEvents) body.max_events = opts.maxEvents;
+    const data = await client.post("/replay", body);
+    const j = data.job;
+    if (isJsonMode()) {
+      printJson(j);
+      return;
+    }
+    printSuccess(`Replay job created`);
+    console.log();
+    printKeyValue([
+      ["Job ID", j.id],
+      ["Destination", j.destination_id],
+      ["Source", j.source_id || "all"],
+      ["From", j.from],
+      ["To", j.to],
+      ["Total Events", String(j.total)],
+      ["Rate Limit", String(j.rate_limit)],
+      ["Status", j.status]
+    ]);
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/replay/status.ts
+import { Command as Command45 } from "commander";
+var replayStatusCommand = new Command45("status").description("Get replay job status").argument("<id>", "Replay job ID").action(async (id) => {
+  try {
+    const client = new hookstreamClient();
+    const data = await client.get(`/replay/${id}`);
+    const j = data.job;
+    if (isJsonMode()) {
+      printJson(j);
+      return;
+    }
+    const progress = j.total > 0 ? Math.round(j.processed / j.total * 100) : 0;
+    console.log();
+    printKeyValue([
+      ["Job ID", j.id],
+      ["Status", statusColor(j.status)],
+      ["Destination", j.destination_id],
+      ["Source", j.source_id || "all"],
+      ["From", j.from],
+      ["To", j.to],
+      ["Progress", `${j.processed}/${j.total} (${progress}%)`],
+      ["Succeeded", String(j.succeeded)],
+      ["Failed", String(j.failed)],
+      ["Rate Limit", String(j.rate_limit)],
+      ["Started", formatDate(j.started_at)],
+      ["Completed", formatDate(j.completed_at)]
+    ]);
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/replay/index.ts
+var replayCommand = new Command46("replay").description("Replay historical events").addCommand(replayCreateCommand).addCommand(replayStatusCommand);
+
+// src/commands/billing/index.ts
+import { Command as Command49 } from "commander";
+
+// src/commands/billing/usage.ts
+import { Command as Command47 } from "commander";
+import chalk6 from "chalk";
+var billingUsageCommand = new Command47("usage").description("Show current plan usage").action(async () => {
+  try {
+    const client = new hookstreamClient();
+    const data = await client.get("/billing/usage");
+    if (isJsonMode()) {
+      printJson(data);
+      return;
+    }
+    const pct = data.events.percentage;
+    const bar = progressBar(pct, 30);
+    const pctColor = pct >= 90 ? chalk6.red : pct >= 80 ? chalk6.yellow : chalk6.green;
+    console.log();
+    console.log(chalk6.bold("  Plan:"), chalk6.cyan(data.plan.toUpperCase()));
+    console.log();
+    console.log(chalk6.dim("  Events this month"));
+    console.log(`  ${bar} ${pctColor(`${pct}%`)}`);
+    console.log(chalk6.dim(`  ${data.events.used.toLocaleString()} / ${data.events.limit === Infinity ? "Unlimited" : data.events.limit.toLocaleString()}`));
+    console.log();
+    printKeyValue([
+      ["Sources", data.sources.limit === Infinity ? `${data.sources.used} (unlimited)` : `${data.sources.used} / ${data.sources.limit}`],
+      ["Destinations", data.destinations.limit === Infinity ? `${data.destinations.used} (unlimited)` : `${data.destinations.used} / ${data.destinations.limit}`],
+      ["Retention", `${data.retention_days} days`]
+    ]);
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+function progressBar(pct, width) {
+  const filled = Math.round(Math.min(pct, 100) / 100 * width);
+  const empty = width - filled;
+  const color = pct >= 90 ? chalk6.red : pct >= 80 ? chalk6.yellow : chalk6.green;
+  return color("\u2588".repeat(filled)) + chalk6.dim("\u2591".repeat(empty));
+}
+
+// src/commands/billing/subscription.ts
+import { Command as Command48 } from "commander";
+import chalk7 from "chalk";
+var billingSubscriptionCommand = new Command48("subscription").description("Show current subscription details").action(async () => {
+  try {
+    const client = new hookstreamClient();
+    const data = await client.get("/billing/subscription");
+    if (isJsonMode()) {
+      printJson(data);
+      return;
+    }
+    console.log();
+    if (!data.subscription) {
+      console.log(chalk7.dim("  No active subscription. You are on the Free plan."));
+      console.log(chalk7.dim("  Upgrade at https://hookstream.io/settings?tab=billing"));
+    } else {
+      const sub = data.subscription;
+      const statusColor2 = sub.status === "active" ? chalk7.green : sub.status === "past_due" ? chalk7.yellow : chalk7.red;
+      printKeyValue([
+        ["Plan", chalk7.cyan(sub.plan.toUpperCase())],
+        ["Status", statusColor2(sub.status)],
+        ["Period Start", formatDate(sub.current_period_start)],
+        ["Period End", formatDate(sub.current_period_end)],
+        ["Cancel at Period End", sub.cancel_at_period_end ? chalk7.yellow("Yes") : "No"],
+        ["Canceled At", sub.canceled_at ? formatDate(sub.canceled_at) : "\u2014"]
+      ]);
+    }
+    console.log();
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+
+// src/commands/billing/index.ts
+var billingCommand = new Command49("billing").description("View billing, usage, and subscription info").addCommand(billingUsageCommand).addCommand(billingSubscriptionCommand);
+
+// src/index.ts
+var program = new Command50();
+program.name("hookstream").description("hookstream CLI \u2014 manage webhooks from the terminal").version("0.1.0").option("--json", "Output as JSON").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.optsWithGlobals();
+  if (opts.json) {
+    setJsonMode(true);
+  }
+});
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(whoamiCommand);
+program.addCommand(sourcesCommand);
+program.addCommand(destinationsCommand);
+program.addCommand(connectionsCommand);
+program.addCommand(eventsCommand);
+program.addCommand(deliveriesCommand);
+program.addCommand(metricsCommand);
+program.addCommand(testCommand);
+program.addCommand(listenCommand);
+program.addCommand(topicsCommand);
+program.addCommand(replayCommand);
+program.addCommand(billingCommand);
+program.parse();