emailr-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1303 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command9 } from "commander";
+
+// src/commands/send.ts
+import { Command } from "commander";
+import { Emailr } from "@emailr/sdk";
+
+// src/config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var CONFIG_PATHS = [
+  path.join(os.homedir(), ".emailrrc"),
+  path.join(os.homedir(), ".config", "emailr", "config.json")
+];
+function loadConfig() {
+  if (process.env.EMAILR_API_KEY) {
+    return {
+      apiKey: process.env.EMAILR_API_KEY,
+      baseUrl: process.env.EMAILR_BASE_URL,
+      format: process.env.EMAILR_FORMAT || "table"
+    };
+  }
+  for (const configPath of CONFIG_PATHS) {
+    if (fs.existsSync(configPath)) {
+      try {
+        const content = fs.readFileSync(configPath, "utf-8");
+        const config = JSON.parse(content);
+        if (config.apiKey) {
+          return {
+            apiKey: config.apiKey,
+            baseUrl: config.baseUrl,
+            format: config.format || "table"
+          };
+        }
+      } catch {
+      }
+    }
+  }
+  throw new Error(
+    'No API key configured.\n\nSet the EMAILR_API_KEY environment variable:\n  export EMAILR_API_KEY=your-api-key\n\nOr create a config file at ~/.emailrrc:\n  { "apiKey": "your-api-key" }\n\nOr run: emailr config set api-key <your-api-key>'
+  );
+}
+function getConfigPath() {
+  const configDir = path.join(os.homedir(), ".config", "emailr");
+  return path.join(configDir, "config.json");
+}
+function saveConfig(config) {
+  const configPath = getConfigPath();
+  const configDir = path.dirname(configPath);
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  let existingConfig = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      existingConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    } catch {
+    }
+  }
+  const newConfig = { ...existingConfig, ...config };
+  fs.writeFileSync(configPath, JSON.stringify(newConfig, null, 2) + "\n");
+}
+function getConfigValue(key) {
+  try {
+    const config = loadConfig();
+    return config[key]?.toString();
+  } catch {
+    return void 0;
+  }
+}
+
+// src/output.ts
+import Table from "cli-table3";
+import chalk from "chalk";
+function output(data, format = "table") {
+  if (format === "json") {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    printTable(data);
+  }
+}
+function printTable(data) {
+  if (Array.isArray(data)) {
+    printArrayTable(data);
+  } else if (typeof data === "object" && data !== null) {
+    printObjectTable(data);
+  } else {
+    console.log(data);
+  }
+}
+function printArrayTable(data) {
+  if (data.length === 0) {
+    console.log(chalk.gray("No results"));
+    return;
+  }
+  const firstItem = data[0];
+  if (typeof firstItem !== "object" || firstItem === null) {
+    data.forEach((item) => console.log(item));
+    return;
+  }
+  const keys = Object.keys(firstItem);
+  const table = new Table({
+    head: keys.map((k) => chalk.cyan(k)),
+    style: { head: [], border: [] }
+  });
+  for (const item of data) {
+    const row = keys.map((key) => {
+      const value = item[key];
+      return formatValue(value);
+    });
+    table.push(row);
+  }
+  console.log(table.toString());
+}
+function printObjectTable(data) {
+  const table = new Table({
+    style: { head: [], border: [] }
+  });
+  for (const [key, value] of Object.entries(data)) {
+    table.push([chalk.cyan(key), formatValue(value)]);
+  }
+  console.log(table.toString());
+}
+function formatValue(value) {
+  if (value === null || value === void 0) {
+    return chalk.gray("-");
+  }
+  if (typeof value === "boolean") {
+    return value ? chalk.green("\u2713") : chalk.red("\u2717");
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function success(message) {
+  console.log(chalk.green("\u2713"), message);
+}
+function error(message) {
+  console.error(chalk.red("\u2717"), message);
+}
+function info(message) {
+  console.log(chalk.blue("\u2139"), message);
+}
+
+// src/commands/send.ts
+function createSendCommand() {
+  const cmd = new Command("send").description("Send an email").requiredOption("--to <email>", "Recipient email address (comma-separated for multiple)").option("--from <email>", "Sender email address").option("--subject <subject>", "Email subject").option("--html <html>", "HTML content").option("--text <text>", "Plain text content").option("--template <id>", "Template ID to use").option("--template-data <json>", "Template data as JSON").option("--cc <emails>", "CC recipients (comma-separated)").option("--bcc <emails>", "BCC recipients (comma-separated)").option("--reply-to <email>", "Reply-to email address").option("--schedule <datetime>", "Schedule send time (ISO 8601)").option("--format <format>", "Output format (json|table)", "table").action(async (options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const to = options.to.split(",").map((e) => e.trim());
+      const request = {
+        to: to.length === 1 ? to[0] : to
+      };
+      if (options.from) request.from = options.from;
+      if (options.subject) request.subject = options.subject;
+      if (options.html) request.html = options.html;
+      if (options.text) request.text = options.text;
+      if (options.template) request.template_id = options.template;
+      if (options.templateData) {
+        try {
+          request.template_data = JSON.parse(options.templateData);
+        } catch {
+          error("Invalid JSON for --template-data");
+          process.exit(1);
+        }
+      }
+      if (options.cc) {
+        const cc = options.cc.split(",").map((e) => e.trim());
+        request.cc = cc.length === 1 ? cc[0] : cc;
+      }
+      if (options.bcc) {
+        const bcc = options.bcc.split(",").map((e) => e.trim());
+        request.bcc = bcc.length === 1 ? bcc[0] : bcc;
+      }
+      if (options.replyTo) request.reply_to_email = options.replyTo;
+      if (options.schedule) request.scheduled_at = options.schedule;
+      const result = await client.emails.send(request);
+      if (options.format === "json") {
+        output(result, "json");
+      } else {
+        success(`Email sent successfully!`);
+        output({
+          "Message ID": result.message_id,
+          Recipients: result.recipients,
+          Status: result.status,
+          ...result.scheduled_at && { "Scheduled At": result.scheduled_at }
+        }, "table");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to send email");
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/contacts.ts
+import { Command as Command2 } from "commander";
+import { Emailr as Emailr2 } from "@emailr/sdk";
+function createContactsCommand() {
+  const cmd = new Command2("contacts").description("Manage contacts");
+  cmd.command("list").description("List all contacts").option("--limit <number>", "Number of contacts to return", "20").option("--offset <number>", "Offset for pagination", "0").option("--subscribed", "Only show subscribed contacts").option("--unsubscribed", "Only show unsubscribed contacts").option("--format <format>", "Output format (json|table)", "table").action(async (options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr2({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const params = {
+        limit: parseInt(options.limit, 10),
+        offset: parseInt(options.offset, 10)
+      };
+      if (options.subscribed) params.subscribed = true;
+      if (options.unsubscribed) params.subscribed = false;
+      const result = await client.contacts.list(params);
+      if (options.format === "json") {
+        output(result, "json");
+      } else {
+        const contacts = result.contacts.map((c) => ({
+          ID: c.id,
+          Email: c.email,
+          Name: [c.first_name, c.last_name].filter(Boolean).join(" ") || "-",
+          Subscribed: c.subscribed,
+          Created: c.created_at
+        }));
+        output(contacts, "table");
+        console.log(`
+Total: ${result.total}`);
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to list contacts");
+      process.exit(1);
+    }
+  });
+  cmd.command("get <id>").description("Get a contact by ID").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr2({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const contact = await client.contacts.get(id);
+      output(contact, options.format);
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to get contact");
+      process.exit(1);
+    }
+  });
+  cmd.command("create").description("Create a new contact").requiredOption("--email <email>", "Contact email address").option("--first-name <name>", "First name").option("--last-name <name>", "Last name").option("--subscribed", "Mark as subscribed (default: true)").option("--metadata <json>", "Metadata as JSON").option("--format <format>", "Output format (json|table)", "table").action(async (options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr2({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const request = {
+        email: options.email
+      };
+      if (options.firstName) request.first_name = options.firstName;
+      if (options.lastName) request.last_name = options.lastName;
+      if (options.subscribed !== void 0) request.subscribed = options.subscribed;
+      if (options.metadata) {
+        try {
+          request.metadata = JSON.parse(options.metadata);
+        } catch {
+          error("Invalid JSON for --metadata");
+          process.exit(1);
+        }
+      }
+      const contact = await client.contacts.create(request);
+      if (options.format === "json") {
+        output(contact, "json");
+      } else {
+        success(`Contact created: ${contact.id}`);
+        output(contact, "table");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to create contact");
+      process.exit(1);
+    }
+  });
+  cmd.command("update <id>").description("Update a contact").option("--email <email>", "New email address").option("--first-name <name>", "First name").option("--last-name <name>", "Last name").option("--subscribed", "Mark as subscribed").option("--unsubscribed", "Mark as unsubscribed").option("--metadata <json>", "Metadata as JSON").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr2({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const request = {};
+      if (options.email) request.email = options.email;
+      if (options.firstName) request.first_name = options.firstName;
+      if (options.lastName) request.last_name = options.lastName;
+      if (options.subscribed) request.subscribed = true;
+      if (options.unsubscribed) request.subscribed = false;
+      if (options.metadata) {
+        try {
+          request.metadata = JSON.parse(options.metadata);
+        } catch {
+          error("Invalid JSON for --metadata");
+          process.exit(1);
+        }
+      }
+      const contact = await client.contacts.update(id, request);
+      if (options.format === "json") {
+        output(contact, "json");
+      } else {
+        success(`Contact updated: ${contact.id}`);
+        output(contact, "table");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to update contact");
+      process.exit(1);
+    }
+  });
+  cmd.command("delete <id>").description("Delete a contact").action(async (id) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr2({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      await client.contacts.delete(id);
+      success(`Contact deleted: ${id}`);
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to delete contact");
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/templates.ts
+import { Command as Command3 } from "commander";
+import { Emailr as Emailr3 } from "@emailr/sdk";
+function createTemplatesCommand() {
+  const cmd = new Command3("templates").description("Manage email templates");
+  cmd.command("list").description("List all templates").option("--limit <number>", "Number of templates to return", "20").option("--page <number>", "Page number", "1").option("--format <format>", "Output format (json|table)", "table").action(async (options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr3({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const result = await client.templates.list({
+        limit: parseInt(options.limit, 10),
+        page: parseInt(options.page, 10)
+      });
+      if (options.format === "json") {
+        output(result, "json");
+      } else {
+        const templates = result.map((t) => ({
+          ID: t.id,
+          Name: t.name,
+          Subject: t.subject,
+          Variables: t.variables?.join(", ") || "-",
+          Created: t.created_at
+        }));
+        output(templates, "table");
+        console.log(`
+Total: ${result.length}`);
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to list templates");
+      process.exit(1);
+    }
+  });
+  cmd.command("get <id>").description("Get a template by ID").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr3({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const template = await client.templates.get(id);
+      output(template, options.format);
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to get template");
+      process.exit(1);
+    }
+  });
+  cmd.command("create").description("Create a new template").requiredOption("--name <name>", "Template name").requiredOption("--subject <subject>", "Email subject").option("--html <html>", "HTML content").option("--text <text>", "Plain text content").option("--html-file <path>", "Read HTML content from file").option("--text-file <path>", "Read text content from file").option("--from <email>", "Default from email").option("--reply-to <email>", "Default reply-to email").option("--preview-text <text>", "Preview text").option("--format <format>", "Output format (json|table)", "table").action(async (options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr3({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const request = {
+        name: options.name,
+        subject: options.subject
+      };
+      if (options.htmlFile) {
+        const fs2 = await import("fs");
+        request.html_content = fs2.readFileSync(options.htmlFile, "utf-8");
+      } else if (options.html) {
+        request.html_content = options.html;
+      }
+      if (options.textFile) {
+        const fs2 = await import("fs");
+        request.text_content = fs2.readFileSync(options.textFile, "utf-8");
+      } else if (options.text) {
+        request.text_content = options.text;
+      }
+      if (options.from) request.from_email = options.from;
+      if (options.replyTo) request.reply_to = options.replyTo;
+      if (options.previewText) request.preview_text = options.previewText;
+      const template = await client.templates.create(request);
+      if (options.format === "json") {
+        output(template, "json");
+      } else {
+        success(`Template created: ${template.id}`);
+        output({
+          ID: template.id,
+          Name: template.name,
+          Subject: template.subject,
+          Variables: template.variables?.join(", ") || "-"
+        }, "table");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to create template");
+      process.exit(1);
+    }
+  });
+  cmd.command("update <id>").description("Update a template").option("--name <name>", "Template name").option("--subject <subject>", "Email subject").option("--html <html>", "HTML content").option("--text <text>", "Plain text content").option("--html-file <path>", "Read HTML content from file").option("--text-file <path>", "Read text content from file").option("--from <email>", "Default from email").option("--reply-to <email>", "Default reply-to email").option("--preview-text <text>", "Preview text").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr3({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const request = {};
+      if (options.name) request.name = options.name;
+      if (options.subject) request.subject = options.subject;
+      if (options.htmlFile) {
+        const fs2 = await import("fs");
+        request.html_content = fs2.readFileSync(options.htmlFile, "utf-8");
+      } else if (options.html) {
+        request.html_content = options.html;
+      }
+      if (options.textFile) {
+        const fs2 = await import("fs");
+        request.text_content = fs2.readFileSync(options.textFile, "utf-8");
+      } else if (options.text) {
+        request.text_content = options.text;
+      }
+      if (options.from) request.from_email = options.from;
+      if (options.replyTo) request.reply_to = options.replyTo;
+      if (options.previewText) request.preview_text = options.previewText;
+      const template = await client.templates.update(id, request);
+      if (options.format === "json") {
+        output(template, "json");
+      } else {
+        success(`Template updated: ${template.id}`);
+        output(template, "table");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to update template");
+      process.exit(1);
+    }
+  });
+  cmd.command("delete <id>").description("Delete a template").action(async (id) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr3({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      await client.templates.delete(id);
+      success(`Template deleted: ${id}`);
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to delete template");
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/domains.ts
+import { Command as Command4 } from "commander";
+import { Emailr as Emailr4 } from "@emailr/sdk";
+function createDomainsCommand() {
+  const cmd = new Command4("domains").description("Manage sending domains");
+  cmd.command("list").description("List all domains").option("--format <format>", "Output format (json|table)", "table").action(async (options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr4({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const domains = await client.domains.list();
+      if (options.format === "json") {
+        output(domains, "json");
+      } else {
+        const formatted = domains.map((d) => ({
+          ID: d.id,
+          Domain: d.domain,
+          Status: d.status,
+          DKIM: d.dkim_verified,
+          SPF: d.spf_verified,
+          DMARC: d.dmarc_verified,
+          Created: d.created_at
+        }));
+        output(formatted, "table");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to list domains");
+      process.exit(1);
+    }
+  });
+  cmd.command("get <id>").description("Get a domain by ID").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr4({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const domain = await client.domains.get(id);
+      output(domain, options.format);
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to get domain");
+      process.exit(1);
+    }
+  });
+  cmd.command("add <domain>").description("Add a new domain").option("--receiving-subdomain <subdomain>", "Subdomain for receiving emails").option("--format <format>", "Output format (json|table)", "table").action(async (domainName, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr4({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const request = {
+        domain: domainName
+      };
+      if (options.receivingSubdomain) {
+        request.receivingSubdomain = options.receivingSubdomain;
+      }
+      const domain = await client.domains.add(request);
+      if (options.format === "json") {
+        output(domain, "json");
+      } else {
+        success(`Domain added: ${domain.domain}`);
+        info("Add the following DNS records to verify your domain:");
+        console.log("");
+        if (domain.dns_records) {
+          const records = [
+            { Type: "DKIM", ...formatDnsRecord(domain.dns_records.dkim) },
+            { Type: "SPF", ...formatDnsRecord(domain.dns_records.spf) },
+            { Type: "DMARC", ...formatDnsRecord(domain.dns_records.dmarc) }
+          ];
+          output(records, "table");
+        }
+        console.log("");
+        info(`Run 'emailr domains verify ${domain.id}' after adding DNS records`);
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to add domain");
+      process.exit(1);
+    }
+  });
+  cmd.command("verify <id>").description("Verify a domain").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr4({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const result = await client.domains.verify(id);
+      if (options.format === "json") {
+        output(result, "json");
+      } else {
+        if (result.verified) {
+          success("Domain verified successfully!");
+        } else {
+          info(`Domain status: ${result.status}`);
+          if (result.dkim_status) {
+            info(`DKIM status: ${result.dkim_status}`);
+          }
+        }
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to verify domain");
+      process.exit(1);
+    }
+  });
+  cmd.command("check-dns <id>").description("Check DNS records for a domain").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr4({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const result = await client.domains.checkDns(id);
+      if (options.format === "json") {
+        output(result, "json");
+      } else {
+        const records = Object.entries(result).map(([name, status]) => ({
+          Record: name,
+          Verified: status.verified,
+          Expected: status.expected || "-",
+          Found: status.found?.join(", ") || "-"
+        }));
+        output(records, "table");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to check DNS");
+      process.exit(1);
+    }
+  });
+  cmd.command("delete <id>").description("Delete a domain").action(async (id) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr4({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      await client.domains.delete(id);
+      success(`Domain deleted: ${id}`);
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to delete domain");
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+function formatDnsRecord(record) {
+  return {
+    "Record Type": record.type,
+    Name: record.name,
+    Value: record.value.length > 50 ? record.value.substring(0, 47) + "..." : record.value,
+    ...record.priority !== void 0 && { Priority: record.priority }
+  };
+}
+
+// src/commands/config.ts
+import { Command as Command5 } from "commander";
+function createConfigCommand() {
+  const cmd = new Command5("config").description("Manage CLI configuration");
+  cmd.command("set <key> <value>").description("Set a configuration value").action(async (key, value) => {
+    try {
+      const validKeys = ["api-key", "base-url", "format"];
+      const normalizedKey = key.toLowerCase();
+      if (!validKeys.includes(normalizedKey)) {
+        error(`Invalid config key: ${key}`);
+        info(`Valid keys: ${validKeys.join(", ")}`);
+        process.exit(1);
+      }
+      const keyMap = {
+        "api-key": "apiKey",
+        "base-url": "baseUrl",
+        "format": "format"
+      };
+      const configKey = keyMap[normalizedKey];
+      if (normalizedKey === "format" && !["json", "table"].includes(value)) {
+        error(`Invalid format value: ${value}`);
+        info("Valid formats: json, table");
+        process.exit(1);
+      }
+      saveConfig({ [configKey]: value });
+      success(`Configuration saved: ${key} = ${normalizedKey === "api-key" ? "***" : value}`);
+      info(`Config file: ${getConfigPath()}`);
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to save configuration");
+      process.exit(1);
+    }
+  });
+  cmd.command("get <key>").description("Get a configuration value").action(async (key) => {
+    try {
+      const validKeys = ["api-key", "base-url", "format"];
+      const normalizedKey = key.toLowerCase();
+      if (!validKeys.includes(normalizedKey)) {
+        error(`Invalid config key: ${key}`);
+        info(`Valid keys: ${validKeys.join(", ")}`);
+        process.exit(1);
+      }
+      const keyMap = {
+        "api-key": "apiKey",
+        "base-url": "baseUrl",
+        "format": "format"
+      };
+      const configKey = keyMap[normalizedKey];
+      const value = getConfigValue(configKey);
+      if (value) {
+        if (normalizedKey === "api-key") {
+          console.log(value.substring(0, 8) + "..." + value.substring(value.length - 4));
+        } else {
+          console.log(value);
+        }
+      } else {
+        info(`${key} is not set`);
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to get configuration");
+      process.exit(1);
+    }
+  });
+  cmd.command("list").description("List all configuration values").option("--format <format>", "Output format (json|table)", "table").action(async (options) => {
+    try {
+      const config = loadConfig();
+      const configData = {
+        "api-key": config.apiKey ? config.apiKey.substring(0, 8) + "..." + config.apiKey.substring(config.apiKey.length - 4) : "(not set)",
+        "base-url": config.baseUrl || "(default)",
+        "format": config.format || "table"
+      };
+      if (options.format === "json") {
+        output(configData, "json");
+      } else {
+        const rows = Object.entries(configData).map(([key, value]) => ({
+          Key: key,
+          Value: value
+        }));
+        output(rows, "table");
+      }
+      console.log("");
+      info(`Config file: ${getConfigPath()}`);
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("No API key configured")) {
+        info("No configuration found.");
+        info(`Run 'emailr config set api-key <your-api-key>' to get started.`);
+      } else {
+        error(err instanceof Error ? err.message : "Failed to list configuration");
+        process.exit(1);
+      }
+    }
+  });
+  cmd.command("path").description("Show the configuration file path").action(() => {
+    console.log(getConfigPath());
+  });
+  cmd.command("init").description("Initialize configuration interactively").option("--api-key <key>", "API key to use").option("--base-url <url>", "Base URL for API").action(async (options) => {
+    try {
+      if (options.apiKey) {
+        saveConfig({
+          apiKey: options.apiKey,
+          baseUrl: options.baseUrl
+        });
+        success("Configuration initialized!");
+        info(`Config file: ${getConfigPath()}`);
+      } else {
+        info("Initialize your Emailr CLI configuration:");
+        console.log("");
+        info("Run with --api-key flag:");
+        console.log("  emailr config init --api-key <your-api-key>");
+        console.log("");
+        info("Or set environment variable:");
+        console.log("  export EMAILR_API_KEY=<your-api-key>");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to initialize configuration");
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/broadcasts.ts
+import { Command as Command6 } from "commander";
+import { Emailr as Emailr5 } from "@emailr/sdk";
+function createBroadcastsCommand() {
+  const cmd = new Command6("broadcasts").description("Manage broadcast campaigns");
+  cmd.command("list").description("List all broadcasts").option("--status <status>", "Filter by status (draft, scheduled, sending, sent)").option("--limit <number>", "Number of broadcasts to return", "20").option("--format <format>", "Output format (json|table)", "table").action(async (options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr5({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const broadcasts = await client.broadcasts.list({
+        status: options.status,
+        limit: parseInt(options.limit)
+      });
+      if (options.format === "json") {
+        output(broadcasts, "json");
+      } else {
+        if (broadcasts.length === 0) {
+          console.log("No broadcasts found.");
+          return;
+        }
+        const tableData = broadcasts.map((b) => ({
+          ID: b.id,
+          Name: b.name,
+          Subject: b.subject.substring(0, 30) + (b.subject.length > 30 ? "..." : ""),
+          Status: b.status,
+          Recipients: b.total_recipients || 0,
+          "Sent": b.sent_count || 0,
+          "Created": new Date(b.created_at).toLocaleDateString()
+        }));
+        output(tableData, "table");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to list broadcasts");
+      process.exit(1);
+    }
+  });
+  cmd.command("get <id>").description("Get broadcast details").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr5({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const broadcast = await client.broadcasts.get(id);
+      if (options.format === "json") {
+        output(broadcast, "json");
+      } else {
+        output({
+          ID: broadcast.id,
+          Name: broadcast.name,
+          Subject: broadcast.subject,
+          "From Email": broadcast.from_email,
+          Status: broadcast.status,
+          "Total Recipients": broadcast.total_recipients || 0,
+          "Sent Count": broadcast.sent_count || 0,
+          "Delivered": broadcast.delivered_count || 0,
+          "Opened": broadcast.opened_count || 0,
+          "Clicked": broadcast.clicked_count || 0,
+          "Bounced": broadcast.bounced_count || 0,
+          "Scheduled At": broadcast.scheduled_at || "N/A",
+          "Started At": broadcast.started_at || "N/A",
+          "Completed At": broadcast.completed_at || "N/A",
+          "Created At": broadcast.created_at
+        }, "table");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to get broadcast");
+      process.exit(1);
+    }
+  });
+  cmd.command("create").description("Create a new broadcast").requiredOption("--name <name>", "Broadcast name").requiredOption("--subject <subject>", "Email subject").requiredOption("--from <email>", "Sender email address").option("--template <id>", "Template ID to use").option("--segment <id>", "Segment ID to target").option("--html <html>", "HTML content").option("--text <text>", "Plain text content").option("--schedule <datetime>", "Schedule time (ISO 8601)").option("--format <format>", "Output format (json|table)", "table").action(async (options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr5({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const broadcast = await client.broadcasts.create({
+        name: options.name,
+        subject: options.subject,
+        from_email: options.from,
+        template_id: options.template,
+        segment_id: options.segment,
+        html_content: options.html,
+        text_content: options.text,
+        scheduled_at: options.schedule
+      });
+      if (options.format === "json") {
+        output(broadcast, "json");
+      } else {
+        success("Broadcast created successfully!");
+        output({
+          ID: broadcast.id,
+          Name: broadcast.name,
+          Status: broadcast.status,
+          "Scheduled At": broadcast.scheduled_at || "Not scheduled"
+        }, "table");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to create broadcast");
+      process.exit(1);
+    }
+  });
+  cmd.command("send <id>").description("Send a broadcast immediately").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr5({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const result = await client.broadcasts.send(id);
+      if (options.format === "json") {
+        output(result, "json");
+      } else {
+        success("Broadcast sent successfully!");
+        output({
+          Success: result.success,
+          Sent: result.sent,
+          Total: result.total
+        }, "table");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to send broadcast");
+      process.exit(1);
+    }
+  });
+  cmd.command("schedule <id>").description("Schedule a broadcast").requiredOption("--at <datetime>", "Schedule time (ISO 8601)").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr5({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const broadcast = await client.broadcasts.schedule(id, options.at);
+      if (options.format === "json") {
+        output(broadcast, "json");
+      } else {
+        success("Broadcast scheduled successfully!");
+        output({
+          ID: broadcast.id,
+          Name: broadcast.name,
+          Status: broadcast.status,
+          "Scheduled At": broadcast.scheduled_at
+        }, "table");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to schedule broadcast");
+      process.exit(1);
+    }
+  });
+  cmd.command("cancel <id>").description("Cancel a scheduled broadcast").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr5({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const result = await client.broadcasts.cancel(id);
+      if (options.format === "json") {
+        output(result, "json");
+      } else {
+        success("Broadcast cancelled successfully!");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to cancel broadcast");
+      process.exit(1);
+    }
+  });
+  cmd.command("delete <id>").description("Delete a broadcast").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr5({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const result = await client.broadcasts.delete(id);
+      if (options.format === "json") {
+        output(result, "json");
+      } else {
+        success("Broadcast deleted successfully!");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to delete broadcast");
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/webhooks.ts
+import { Command as Command7 } from "commander";
+import { Emailr as Emailr6 } from "@emailr/sdk";
+function createWebhooksCommand() {
+  const cmd = new Command7("webhooks").description("Manage webhooks");
+  cmd.command("list").description("List all webhooks").option("--format <format>", "Output format (json|table)", "table").action(async (options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr6({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const webhooks = await client.webhooks.list();
+      if (options.format === "json") {
+        output(webhooks, "json");
+      } else {
+        if (webhooks.length === 0) {
+          console.log("No webhooks found.");
+          return;
+        }
+        const tableData = webhooks.map((w) => ({
+          ID: w.id,
+          Name: w.name,
+          URL: w.url.substring(0, 40) + (w.url.length > 40 ? "..." : ""),
+          Events: w.events.join(", "),
+          Active: w.active ? "Yes" : "No"
+        }));
+        output(tableData, "table");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to list webhooks");
+      process.exit(1);
+    }
+  });
+  cmd.command("get <id>").description("Get webhook details").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr6({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const webhook = await client.webhooks.get(id);
+      if (options.format === "json") {
+        output(webhook, "json");
+      } else {
+        output({
+          ID: webhook.id,
+          Name: webhook.name,
+          URL: webhook.url,
+          Events: webhook.events.join(", "),
+          Active: webhook.active ? "Yes" : "No",
+          Secret: webhook.secret,
+          "Created At": webhook.created_at
+        }, "table");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to get webhook");
+      process.exit(1);
+    }
+  });
+  cmd.command("create").description("Create a new webhook").requiredOption("--name <name>", "Webhook name").requiredOption("--url <url>", "Webhook URL").requiredOption("--events <events>", "Events to subscribe to (comma-separated)").option("--format <format>", "Output format (json|table)", "table").action(async (options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr6({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const events = options.events.split(",").map((e) => e.trim());
+      const webhook = await client.webhooks.create({
+        name: options.name,
+        url: options.url,
+        events
+      });
+      if (options.format === "json") {
+        output(webhook, "json");
+      } else {
+        success("Webhook created successfully!");
+        output({
+          ID: webhook.id,
+          Name: webhook.name,
+          URL: webhook.url,
+          Secret: webhook.secret
+        }, "table");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to create webhook");
+      process.exit(1);
+    }
+  });
+  cmd.command("update <id>").description("Update a webhook").option("--name <name>", "New webhook name").option("--url <url>", "New webhook URL").option("--events <events>", "New events (comma-separated)").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr6({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const updateData = {};
+      if (options.name) updateData.name = options.name;
+      if (options.url) updateData.url = options.url;
+      if (options.events) {
+        updateData.events = options.events.split(",").map((e) => e.trim());
+      }
+      const webhook = await client.webhooks.update(id, updateData);
+      if (options.format === "json") {
+        output(webhook, "json");
+      } else {
+        success("Webhook updated successfully!");
+        output({
+          ID: webhook.id,
+          Name: webhook.name,
+          URL: webhook.url
+        }, "table");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to update webhook");
+      process.exit(1);
+    }
+  });
+  cmd.command("enable <id>").description("Enable a webhook").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr6({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const result = await client.webhooks.enable(id);
+      if (options.format === "json") {
+        output(result, "json");
+      } else {
+        success("Webhook enabled successfully!");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to enable webhook");
+      process.exit(1);
+    }
+  });
+  cmd.command("disable <id>").description("Disable a webhook").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr6({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const result = await client.webhooks.disable(id);
+      if (options.format === "json") {
+        output(result, "json");
+      } else {
+        success("Webhook disabled successfully!");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to disable webhook");
+      process.exit(1);
+    }
+  });
+  cmd.command("delete <id>").description("Delete a webhook").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr6({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const result = await client.webhooks.delete(id);
+      if (options.format === "json") {
+        output(result, "json");
+      } else {
+        success("Webhook deleted successfully!");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to delete webhook");
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/segments.ts
+import { Command as Command8 } from "commander";
+import { Emailr as Emailr7 } from "@emailr/sdk";
+function createSegmentsCommand() {
+  const cmd = new Command8("segments").description("Manage contact segments");
+  cmd.command("list").description("List all segments").option("--format <format>", "Output format (json|table)", "table").action(async (options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr7({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const segments = await client.segments.list();
+      if (options.format === "json") {
+        output(segments, "json");
+      } else {
+        if (segments.length === 0) {
+          console.log("No segments found.");
+          return;
+        }
+        const tableData = segments.map((s) => ({
+          ID: s.id,
+          Name: s.name,
+          Description: (s.description || "").substring(0, 30) + ((s.description?.length || 0) > 30 ? "..." : ""),
+          "Created At": new Date(s.created_at).toLocaleDateString()
+        }));
+        output(tableData, "table");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to list segments");
+      process.exit(1);
+    }
+  });
+  cmd.command("get <id>").description("Get segment details").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr7({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const segment = await client.segments.get(id);
+      if (options.format === "json") {
+        output(segment, "json");
+      } else {
+        output({
+          ID: segment.id,
+          Name: segment.name,
+          Description: segment.description || "N/A",
+          Conditions: JSON.stringify(segment.conditions),
+          "Created At": segment.created_at,
+          "Updated At": segment.updated_at
+        }, "table");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to get segment");
+      process.exit(1);
+    }
+  });
+  cmd.command("create").description("Create a new segment").requiredOption("--name <name>", "Segment name").requiredOption("--conditions <json>", "Segment conditions as JSON").option("--description <description>", "Segment description").option("--format <format>", "Output format (json|table)", "table").action(async (options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr7({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      let conditions;
+      try {
+        conditions = JSON.parse(options.conditions);
+      } catch {
+        error("Invalid JSON for --conditions");
+        process.exit(1);
+      }
+      const segment = await client.segments.create({
+        name: options.name,
+        description: options.description,
+        conditions
+      });
+      if (options.format === "json") {
+        output(segment, "json");
+      } else {
+        success("Segment created successfully!");
+        output({
+          ID: segment.id,
+          Name: segment.name
+        }, "table");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to create segment");
+      process.exit(1);
+    }
+  });
+  cmd.command("update <id>").description("Update a segment").option("--name <name>", "New segment name").option("--description <description>", "New description").option("--conditions <json>", "New conditions as JSON").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr7({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const updateData = {};
+      if (options.name) updateData.name = options.name;
+      if (options.description) updateData.description = options.description;
+      if (options.conditions) {
+        try {
+          updateData.conditions = JSON.parse(options.conditions);
+        } catch {
+          error("Invalid JSON for --conditions");
+          process.exit(1);
+        }
+      }
+      const segment = await client.segments.update(id, updateData);
+      if (options.format === "json") {
+        output(segment, "json");
+      } else {
+        success("Segment updated successfully!");
+        output({
+          ID: segment.id,
+          Name: segment.name
+        }, "table");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to update segment");
+      process.exit(1);
+    }
+  });
+  cmd.command("delete <id>").description("Delete a segment").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr7({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const result = await client.segments.delete(id);
+      if (options.format === "json") {
+        output(result, "json");
+      } else {
+        success("Segment deleted successfully!");
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to delete segment");
+      process.exit(1);
+    }
+  });
+  cmd.command("count <id>").description("Get the number of contacts in a segment").option("--format <format>", "Output format (json|table)", "table").action(async (id, options) => {
+    try {
+      const config = loadConfig();
+      const client = new Emailr7({
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+      const result = await client.segments.getContactsCount(id);
+      if (options.format === "json") {
+        output(result, "json");
+      } else {
+        console.log(`Segment contains ${result.count} contacts.`);
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to get segment count");
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/index.ts
+var program = new Command9();
+program.name("emailr").description("Emailr CLI - Send emails and manage your email infrastructure").version("1.0.0");
+program.addCommand(createSendCommand());
+program.addCommand(createContactsCommand());
+program.addCommand(createTemplatesCommand());
+program.addCommand(createDomainsCommand());
+program.addCommand(createBroadcastsCommand());
+program.addCommand(createWebhooksCommand());
+program.addCommand(createSegmentsCommand());
+program.addCommand(createConfigCommand());
+program.parse();