@sesender/cli 1.0.0 → 1.0.3

package/src/commands/sms.mjs

@@ -1,66 +1,123 @@
 import { readFileSync } from "fs";
 import { apiRequest } from "../api.mjs";
-import { formatTable, outputResult, success } from "../output.mjs";
+import { formatTable, outputResult, success, info } from "../output.mjs";
 
 export async function smsSend(args, jsonMode) {
   const to = args["--to"];
-  const body = args["--body"];
-  const from = args["--from"];
+  const body = args["--body"] || args["--message"];
+  const from = args["--from"] || args["--sender"];
+  const provider = args["--provider"];
+  const route = args["--route"];
+  const schedule = args["--schedule"];
 
   if (!to || !body) {
-    console.error("Usage: ses-cli sms send --to PHONE --body MESSAGE [--from SENDER_ID]");
+    console.error(`
+Usage: ses-cli sms send --to PHONE --body MESSAGE [options]
+
+Options:
+  --to          Recipient phone number (E.164 format, e.g., +1234567890)
+  --body        SMS message text (aliases: --message)
+  --from        Sender ID or phone number (aliases: --sender)
+  --provider    Provider ID to use (see: ses-cli providers list)
+  --route       Route name for the provider (e.g., DEFAULT, PREMIUM)
+  --schedule    Schedule send time (ISO 8601, e.g., 2026-06-15T09:00:00Z)
+
+Examples:
+  ses-cli sms send --to +1234567890 --body "Hello!"
+  ses-cli sms send --to +1234567890 --body "VIP offer" --provider 5 --route PREMIUM
+  ses-cli sms send --to +1234567890 --body "Reminder" --schedule "2026-06-15T09:00:00Z"
+`);
     process.exit(1);
   }
 
-  const payload = { to, body };
-  if (from) payload.from = from;
+  const payload = { to, message: body };
+  if (from) payload.senderId = from;
+  if (provider) payload.providerId = parseInt(provider);
+  if (route) payload.routeName = route;
+  if (schedule) payload.scheduledAt = schedule;
 
   const result = await apiRequest("POST", "/sms/send", payload);
 
   if (jsonMode) {
     outputResult(result, true);
   } else {
-    success(`SMS sent to ${to}`);
-    if (result.messageId) console.log(`  Message ID: ${result.messageId}`);
-    if (result.cost) console.log(`  Cost: $${result.cost}`);
+    success(`SMS ${schedule ? "scheduled" : "sent"} to ${to}`);
+    if (result.data?.messageId) console.log(`  Message ID: ${result.data.messageId}`);
+    if (result.data?.provider) console.log(`  Provider: ${result.data.provider}`);
+    if (schedule) console.log(`  Scheduled: ${schedule}`);
   }
 }
 
 export async function smsBulk(args, jsonMode) {
   const file = args["--file"];
-  const body = args["--body"];
-  const from = args["--from"];
-
-  if (!file) {
-    console.error("Usage: ses-cli sms bulk --file contacts.csv --body MESSAGE [--from SENDER_ID]");
-    console.error("\nCSV format: phone (one number per line, or column header 'phone')");
+  const body = args["--body"] || args["--message"];
+  const from = args["--from"] || args["--sender"];
+  const provider = args["--provider"];
+  const route = args["--route"];
+  const schedule = args["--schedule"];
+  const delay = parseInt(args["--delay"] || "0");
+
+  if (!file || !body) {
+    console.error(`
+Usage: ses-cli sms bulk --file FILE --body MESSAGE [options]
+
+Options:
+  --file        CSV file with phone numbers (column: phone or first column)
+  --body        SMS message text. Use [[ColumnName]] for personalization
+  --from        Sender ID or phone number
+  --provider    Provider ID to use
+  --route       Route name (e.g., DEFAULT, PREMIUM)
+  --schedule    Schedule send time (ISO 8601)
+  --delay       Delay between messages in ms (default: 0)
+
+Personalization:
+  Use [[First]], [[Last]], [[Custom1]], etc. in your message body.
+  Column names are matched from your CSV headers.
+
+Examples:
+  ses-cli sms bulk --file contacts.csv --body "Hi [[First]], check out our sale!"
+  ses-cli sms bulk --file vip.csv --body "VIP: 50% off" --provider 3 --route PREMIUM
+`);
     process.exit(1);
   }
 
   const csvContent = readFileSync(file, "utf-8");
   const lines = csvContent.trim().split("\n");
-  const hasHeader = lines[0].toLowerCase().includes("phone");
-  const numbers = (hasHeader ? lines.slice(1) : lines)
-    .map((l) => l.trim().split(",")[0].trim())
-    .filter(Boolean);
+  const headers = lines[0].toLowerCase().split(",").map(h => h.trim().replace(/"/g, ""));
+  const phoneIdx = headers.indexOf("phone") !== -1 ? headers.indexOf("phone") : 0;
+  const dataLines = lines.slice(1);
 
-  if (numbers.length === 0) {
-    console.error("Error: No phone numbers found in CSV file");
+  if (dataLines.length === 0) {
+    console.error("Error: No data rows found in CSV file");
     process.exit(1);
   }
 
-  console.log(`Sending to ${numbers.length} recipients...`);
+  info(`Sending to ${dataLines.length} recipients...`);
 
   let sent = 0;
   let failed = 0;
   const errors = [];
 
-  for (const phone of numbers) {
+  for (const line of dataLines) {
+    const cols = line.split(",").map(c => c.trim().replace(/"/g, ""));
+    const phone = cols[phoneIdx];
+    if (!phone) continue;
+
+    // Replace personalization tokens
+    let personalizedBody = body;
+    headers.forEach((header, idx) => {
+      const regex = new RegExp(`\\[\\[${header}\\]\\]`, "gi");
+      personalizedBody = personalizedBody.replace(regex, cols[idx] || "");
+    });
+
     try {
-      const payload = { to: phone, body };
-      if (from) payload.from = from;
+      const payload = { to: phone, message: personalizedBody };
+      if (from) payload.senderId = from;
+      if (provider) payload.providerId = parseInt(provider);
+      if (route) payload.routeName = route;
       await apiRequest("POST", "/sms/send", payload);
       sent++;
+      if (delay > 0) await new Promise(r => setTimeout(r, delay));
     } catch {
       failed++;
       errors.push(phone);
@@ -68,11 +125,11 @@ export async function smsBulk(args, jsonMode) {
   }
 
   if (jsonMode) {
-    outputResult({ sent, failed, total: numbers.length, errors }, true);
+    outputResult({ sent, failed, total: dataLines.length, errors }, true);
   } else {
-    success(`Bulk SMS complete: ${sent} sent, ${failed} failed out of ${numbers.length}`);
+    success(`Bulk SMS complete: ${sent} sent, ${failed} failed out of ${dataLines.length}`);
     if (errors.length > 0) {
-      console.log(`  Failed numbers: ${errors.slice(0, 5).join(", ")}${errors.length > 5 ? "..." : ""}`);
+      console.log(`  Failed: ${errors.slice(0, 5).join(", ")}${errors.length > 5 ? ` +${errors.length - 5} more` : ""}`);
     }
   }
 }
@@ -80,24 +137,29 @@ export async function smsBulk(args, jsonMode) {
 export async function smsHistory(args, jsonMode) {
   const limit = args["--limit"] || "20";
   const page = args["--page"] || "1";
+  const status = args["--status"];
+
+  const params = { limit, page };
+  if (status) params.status = status;
 
-  const result = await apiRequest("GET", "/sms/history", null, { limit, page });
+  const result = await apiRequest("GET", "/sms/messages", null, params);
 
   if (jsonMode) {
     outputResult(result, true);
   } else {
-    const messages = result.messages || result.data || [];
+    const messages = result.data?.messages || result.messages || result.data || [];
     if (messages.length === 0) {
       console.log("No SMS messages found.");
       return;
     }
     formatTable(
-      ["To", "Status", "Date", "Body"],
+      ["To", "Status", "Provider", "Date", "Body"],
       messages.map((m) => [
         m.to || m.recipient,
         m.status || "sent",
+        m.provider || "-",
         new Date(m.createdAt || m.sentAt).toLocaleString(),
-        (m.body || m.message || "").slice(0, 40),
+        (m.body || m.message || "").slice(0, 30),
       ])
     );
     console.log(`\nShowing ${messages.length} messages (page ${page})`);

package/src/commands/templates.mjs

@@ -0,0 +1,57 @@
+import { apiRequest } from "../api.mjs";
+import { formatTable, outputResult, success } from "../output.mjs";
+
+export async function templatesList(args, jsonMode) {
+  const type = args["--type"]; // sms or email
+
+  const params = {};
+  if (type) params.type = type;
+
+  const result = await apiRequest("GET", "/templates", null, params);
+
+  if (jsonMode) {
+    outputResult(result, true);
+  } else {
+    const templates = result.data?.templates || result.templates || result.data || [];
+    if (templates.length === 0) {
+      console.log("No templates found. Create templates in your SESender dashboard.");
+      return;
+    }
+    formatTable(
+      ["ID", "Name", "Type", "Subject/Preview", "Created"],
+      templates.map((t) => [
+        t.id,
+        (t.name || "Untitled").slice(0, 20),
+        t.type || "email",
+        (t.subject || t.body || "").slice(0, 25),
+        t.createdAt ? new Date(t.createdAt).toLocaleDateString() : "-",
+      ])
+    );
+    console.log(`\n${templates.length} template(s) found`);
+  }
+}
+
+export async function templatesGet(args, jsonMode) {
+  const id = args["--id"];
+
+  if (!id) {
+    console.error("Usage: ses-cli templates get --id TEMPLATE_ID");
+    process.exit(1);
+  }
+
+  const result = await apiRequest("GET", `/templates/${id}`);
+
+  if (jsonMode) {
+    outputResult(result, true);
+  } else {
+    const t = result.data || result;
+    console.log(`Template: ${t.name || "Untitled"}`);
+    console.log(`  ID: ${t.id}`);
+    console.log(`  Type: ${t.type || "email"}`);
+    if (t.subject) console.log(`  Subject: ${t.subject}`);
+    if (t.body) {
+      console.log(`  Body:`);
+      console.log(`    ${t.body.slice(0, 200)}${t.body.length > 200 ? "..." : ""}`);
+    }
+  }
+}

package/src/commands/tracking.mjs

@@ -0,0 +1,61 @@
+import { apiRequest } from "../api.mjs";
+import { formatTable, outputResult, success } from "../output.mjs";
+
+export async function trackingDomainsList(args, jsonMode) {
+  const result = await apiRequest("GET", "/tracking-domains");
+
+  if (jsonMode) {
+    outputResult(result, true);
+  } else {
+    const domains = result.data?.domains || result.domains || result.data || [];
+    if (domains.length === 0) {
+      console.log("No tracking domains configured. Add them in your SESender dashboard.");
+      return;
+    }
+    formatTable(
+      ["ID", "Domain", "Status", "SSL", "Clicks (24h)"],
+      domains.map((d) => [
+        d.id,
+        d.domain || d.name,
+        d.status || (d.isVerified ? "Verified" : "Pending"),
+        d.sslEnabled ? "Yes" : "No",
+        d.clicksToday || d.clicks24h || 0,
+      ])
+    );
+    console.log(`\n${domains.length} tracking domain(s)`);
+  }
+}
+
+export async function trackingStats(args, jsonMode) {
+  const domain = args["--domain"];
+  const period = args["--period"] || "7d";
+
+  const params = { period };
+  if (domain) params.domain = domain;
+
+  const result = await apiRequest("GET", "/tracking-domains/stats", null, params);
+
+  if (jsonMode) {
+    outputResult(result, true);
+  } else {
+    const data = result.data || result;
+    console.log(`\n  Tracking Statistics (${period})`);
+    console.log(`  ─────────────────────────`);
+    console.log(`  Total Clicks:   ${data.totalClicks || 0}`);
+    console.log(`  Unique Clicks:  ${data.uniqueClicks || 0}`);
+    console.log(`  Total Opens:    ${data.totalOpens || 0}`);
+    console.log(`  Unique Opens:   ${data.uniqueOpens || 0}`);
+    if (data.topLinks && data.topLinks.length > 0) {
+      console.log(`\n  Top Links:`);
+      formatTable(
+        ["URL", "Clicks", "Unique"],
+        data.topLinks.slice(0, 10).map(l => [
+          (l.url || l.originalUrl || "").slice(0, 35),
+          l.clicks || 0,
+          l.uniqueClicks || 0,
+        ])
+      );
+    }
+    console.log("");
+  }
+}

package/src/commands/validate.mjs

@@ -1,12 +1,25 @@
+import { readFileSync } from "fs";
 import { apiRequest } from "../api.mjs";
-import { outputResult, success } from "../output.mjs";
+import { formatTable, outputResult, success, info } from "../output.mjs";
 
 export async function validatePhone(args, jsonMode) {
   const phone = args["--phone"] || args._positional?.[0];
 
   if (!phone) {
-    console.error("Usage: ses-cli validate phone --phone PHONE_NUMBER");
-    console.error("   or: ses-cli validate phone +1234567890");
+    console.error(`
+Usage: ses-cli validate phone PHONE_NUMBER
+       ses-cli validate phone --phone PHONE_NUMBER
+
+Checks:
+  - Format validity
+  - Country detection
+  - Carrier lookup
+  - Line type (mobile, landline, voip)
+
+Examples:
+  ses-cli validate phone +1234567890
+  ses-cli validate phone --phone "+44 7911 123456"
+`);
     process.exit(1);
   }
 
@@ -15,12 +28,15 @@ export async function validatePhone(args, jsonMode) {
   if (jsonMode) {
     outputResult(result, true);
   } else {
-    console.log(`Phone: ${phone}`);
-    console.log(`  Valid:    ${result.valid ? "✓ Yes" : "✗ No"}`);
-    if (result.carrier) console.log(`  Carrier:  ${result.carrier}`);
-    if (result.type) console.log(`  Type:     ${result.type}`);
-    if (result.country) console.log(`  Country:  ${result.country}`);
-    if (result.formatted) console.log(`  Format:   ${result.formatted}`);
+    const data = result.data || result;
+    console.log(`\n  Phone Validation: ${phone}`);
+    console.log(`  ─────────────────────────`);
+    console.log(`  Valid:    ${data.valid ? "Yes" : "No"}`);
+    if (data.country || data.countryCode) console.log(`  Country: ${data.country || data.countryCode}`);
+    if (data.carrier) console.log(`  Carrier: ${data.carrier}`);
+    if (data.type || data.lineType) console.log(`  Type:    ${data.type || data.lineType}`);
+    if (data.formatted) console.log(`  Format:  ${data.formatted}`);
+    console.log("");
   }
 }
 
@@ -28,8 +44,21 @@ export async function validateEmail(args, jsonMode) {
   const email = args["--email"] || args._positional?.[0];
 
   if (!email) {
-    console.error("Usage: ses-cli validate email --email ADDRESS");
-    console.error("   or: ses-cli validate email user@example.com");
+    console.error(`
+Usage: ses-cli validate email EMAIL_ADDRESS
+       ses-cli validate email --email EMAIL_ADDRESS
+
+Checks:
+  - Syntax validity
+  - MX record existence
+  - Disposable email detection
+  - Role-based address detection
+  - Deliverability score
+
+Examples:
+  ses-cli validate email user@example.com
+  ses-cli validate email --email "test@gmail.com"
+`);
     process.exit(1);
   }
 
@@ -38,10 +67,77 @@ export async function validateEmail(args, jsonMode) {
   if (jsonMode) {
     outputResult(result, true);
   } else {
-    console.log(`Email: ${email}`);
-    console.log(`  Valid:       ${result.valid ? "✓ Yes" : "✗ No"}`);
-    if (result.disposable !== undefined) console.log(`  Disposable:  ${result.disposable ? "⚠ Yes" : "No"}`);
-    if (result.mx) console.log(`  MX Record:   ${result.mx}`);
-    if (result.reason) console.log(`  Reason:      ${result.reason}`);
+    const data = result.data || result;
+    console.log(`\n  Email Validation: ${email}`);
+    console.log(`  ─────────────────────────`);
+    console.log(`  Valid:       ${data.valid ? "Yes" : "No"}`);
+    if (data.mx !== undefined || data.mxValid !== undefined) console.log(`  MX Record:  ${(data.mx || data.mxValid) ? "Yes" : "No"}`);
+    if (data.disposable !== undefined) console.log(`  Disposable: ${data.disposable ? "Yes" : "No"}`);
+    if (data.roleBased !== undefined) console.log(`  Role-based: ${data.roleBased ? "Yes" : "No"}`);
+    if (data.freeProvider !== undefined) console.log(`  Free:       ${data.freeProvider ? "Yes" : "No"}`);
+    if (data.score !== undefined) console.log(`  Score:      ${data.score}/100`);
+    if (data.reason) console.log(`  Reason:     ${data.reason}`);
+    if (data.suggestion) console.log(`  Suggestion: ${data.suggestion}`);
+    console.log("");
+  }
+}
+
+export async function validateBulk(args, jsonMode) {
+  const file = args["--file"];
+  const type = args["--type"] || "email";
+
+  if (!file) {
+    console.error(`
+Usage: ses-cli validate bulk --file FILE [--type email|phone]
+
+Options:
+  --file    CSV file with emails or phone numbers (one per line or first column)
+  --type    Type of validation: "email" (default) or "phone"
+
+Examples:
+  ses-cli validate bulk --file emails.csv --type email
+  ses-cli validate bulk --file phones.csv --type phone
+`);
+    process.exit(1);
+  }
+
+  const csvContent = readFileSync(file, "utf-8");
+  const lines = csvContent.trim().split("\n");
+  const hasHeader = lines[0].toLowerCase().includes(type) || lines[0].toLowerCase().includes("@") === false;
+  const items = (hasHeader ? lines.slice(1) : lines)
+    .map(l => l.trim().split(",")[0].trim().replace(/"/g, ""))
+    .filter(Boolean);
+
+  if (items.length === 0) {
+    console.error("Error: No items found in file");
+    process.exit(1);
+  }
+
+  if (items.length > 500) {
+    console.error("Error: Maximum 500 items per batch. Split your file.");
+    process.exit(1);
+  }
+
+  info(`Validating ${items.length} ${type}(s)...`);
+
+  const result = await apiRequest("POST", `/validate/bulk`, { items, type });
+
+  if (jsonMode) {
+    outputResult(result, true);
+  } else {
+    const data = result.data || result;
+    const valid = data.valid || 0;
+    const invalid = data.invalid || 0;
+    const invalidItems = data.invalidItems || [];
+
+    success(`Validation complete: ${valid} valid, ${invalid} invalid out of ${items.length}`);
+    if (invalidItems.length > 0 && invalidItems.length <= 10) {
+      console.log(`\n  Invalid ${type}s:`);
+      invalidItems.forEach(i => console.log(`    - ${i}`));
+    } else if (invalidItems.length > 10) {
+      console.log(`\n  First 10 invalid ${type}s:`);
+      invalidItems.slice(0, 10).forEach(i => console.log(`    - ${i}`));
+      console.log(`    ... and ${invalidItems.length - 10} more`);
+    }
   }
 }

package/src/commands/webhooks.mjs

@@ -0,0 +1,103 @@
+import { apiRequest } from "../api.mjs";
+import { formatTable, outputResult, success } from "../output.mjs";
+
+export async function webhooksList(args, jsonMode) {
+  const result = await apiRequest("GET", "/webhooks");
+
+  if (jsonMode) {
+    outputResult(result, true);
+  } else {
+    const webhooks = result.data?.webhooks || result.webhooks || result.data || [];
+    if (webhooks.length === 0) {
+      console.log("No webhooks configured.");
+      return;
+    }
+    formatTable(
+      ["ID", "URL", "Events", "Status"],
+      webhooks.map((w) => [
+        w.id,
+        (w.url || "").slice(0, 40),
+        (w.events || []).join(", ").slice(0, 30),
+        w.isActive ? "Active" : "Inactive",
+      ])
+    );
+  }
+}
+
+export async function webhooksCreate(args, jsonMode) {
+  const url = args["--url"];
+  const events = args["--events"];
+
+  if (!url || !events) {
+    console.error(`
+Usage: ses-cli webhooks create --url URL --events EVENTS
+
+Options:
+  --url         Webhook endpoint URL (must be HTTPS)
+  --events      Comma-separated list of events to subscribe to
+
+Available Events:
+  email.sent, email.delivered, email.bounced, email.complained
+  sms.sent, sms.delivered, sms.failed
+  link.clicked, email.opened
+
+Examples:
+  ses-cli webhooks create --url https://myapp.com/webhook --events "email.delivered,email.bounced"
+  ses-cli webhooks create --url https://myapp.com/sms-hook --events "sms.sent,sms.delivered,sms.failed"
+`);
+    process.exit(1);
+  }
+
+  const payload = {
+    url,
+    events: events.split(",").map(e => e.trim()),
+  };
+
+  const result = await apiRequest("POST", "/webhooks", payload);
+
+  if (jsonMode) {
+    outputResult(result, true);
+  } else {
+    success(`Webhook created: ${url}`);
+    if (result.data?.id) console.log(`  ID: ${result.data.id}`);
+    if (result.data?.secret) console.log(`  Secret: ${result.data.secret}`);
+  }
+}
+
+export async function webhooksDelete(args, jsonMode) {
+  const id = args["--id"];
+
+  if (!id) {
+    console.error("Usage: ses-cli webhooks delete --id WEBHOOK_ID");
+    process.exit(1);
+  }
+
+  const result = await apiRequest("DELETE", `/webhooks/${id}`);
+
+  if (jsonMode) {
+    outputResult(result, true);
+  } else {
+    success(`Webhook ${id} deleted`);
+  }
+}
+
+export async function webhooksTest(args, jsonMode) {
+  const id = args["--id"];
+
+  if (!id) {
+    console.error("Usage: ses-cli webhooks test --id WEBHOOK_ID");
+    process.exit(1);
+  }
+
+  const result = await apiRequest("POST", `/webhooks/${id}/test`);
+
+  if (jsonMode) {
+    outputResult(result, true);
+  } else {
+    if (result.data?.success || result.success) {
+      success(`Test webhook sent to webhook ${id}`);
+    } else {
+      console.error(`Webhook test failed: ${result.data?.error || "Unknown error"}`);
+    }
+  }
+}