@sesender/cli 1.0.0 → 1.0.1

package/src/commands/contacts.mjs

@@ -1,32 +1,36 @@
 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 contactsList(args, jsonMode) {
   const limit = args["--limit"] || "20";
   const page = args["--page"] || "1";
   const group = args["--group"];
+  const search = args["--search"];
 
   const params = { limit, page };
   if (group) params.group = group;
+  if (search) params.search = search;
 
   const result = await apiRequest("GET", "/contacts", null, params);
 
   if (jsonMode) {
     outputResult(result, true);
   } else {
-    const contacts = result.contacts || result.data || [];
+    const contacts = result.data?.contacts || result.contacts || result.data || [];
     if (contacts.length === 0) {
       console.log("No contacts found.");
       return;
     }
     formatTable(
-      ["Name", "Phone", "Email", "Groups"],
+      ["ID", "Name", "Email", "Phone", "Group", "Created"],
       contacts.map((c) => [
-        c.name || c.firstName || "-",
+        c.id,
+        (c.name || c.firstName || "-").slice(0, 15),
+        (c.email || "-").slice(0, 25),
         c.phone || "-",
-        c.email || "-",
-        (c.groups || []).join(", ") || "-",
+        (c.groups || []).join(", ").slice(0, 12) || c.group || "-",
+        c.createdAt ? new Date(c.createdAt).toLocaleDateString() : "-",
       ])
     );
     console.log(`\nShowing ${contacts.length} contacts (page ${page})`);
@@ -37,10 +41,25 @@ export async function contactsList(args, jsonMode) {
 export async function contactsImport(args, jsonMode) {
   const file = args["--file"];
   const group = args["--group"];
+  const skipDuplicates = args["--skip-duplicates"] !== undefined;
 
   if (!file) {
-    console.error("Usage: ses-cli contacts import --file contacts.csv [--group GROUP_NAME]");
-    console.error("\nCSV format: name,phone,email (first row as headers)");
+    console.error(`
+Usage: ses-cli contacts import --file FILE [options]
+
+Options:
+  --file              CSV file to import (required)
+  --group             Assign contacts to this group
+  --skip-duplicates   Skip duplicate contacts instead of updating
+
+CSV Format:
+  Headers should include: email, phone, firstName, lastName, custom1, custom2, etc.
+  Minimum: email OR phone column required.
+
+Examples:
+  ses-cli contacts import --file contacts.csv
+  ses-cli contacts import --file leads.csv --group "Newsletter" --skip-duplicates
+`);
     process.exit(1);
   }
 
@@ -52,28 +71,34 @@ export async function contactsImport(args, jsonMode) {
     process.exit(1);
   }
 
-  const headers = lines[0].split(",").map((h) => h.trim().toLowerCase());
+  const headers = lines[0].split(",").map((h) => h.trim().toLowerCase().replace(/"/g, ""));
   const contacts = lines.slice(1).map((line) => {
-    const values = line.split(",").map((v) => v.trim());
+    const values = line.split(",").map((v) => v.trim().replace(/"/g, ""));
     const contact = {};
     headers.forEach((h, i) => {
       if (values[i]) contact[h] = values[i];
     });
     return contact;
-  });
+  }).filter(c => c.email || c.phone);
+
+  info(`Importing ${contacts.length} contacts...`);
 
   const payload = { contacts };
   if (group) payload.group = group;
+  if (skipDuplicates) payload.skipDuplicates = true;
 
   const result = await apiRequest("POST", "/contacts/bulk", payload);
 
   if (jsonMode) {
     outputResult(result, true);
   } else {
-    success(`Import complete: ${result.imported || result.created || contacts.length} contacts imported`);
-    if (result.duplicates) console.log(`  Duplicates skipped: ${result.duplicates}`);
-    if (result.errors) console.log(`  Errors: ${result.errors}`);
-    if (group) console.log(`  Assigned to group: ${group}`);
+    const data = result.data || result;
+    success(`Import complete`);
+    console.log(`  Imported: ${data.imported || data.created || contacts.length}`);
+    if (data.updated) console.log(`  Updated:  ${data.updated}`);
+    if (data.duplicates || data.skipped) console.log(`  Skipped:  ${data.duplicates || data.skipped}`);
+    if (data.errors) console.log(`  Errors:   ${data.errors}`);
+    if (group) console.log(`  Group:    ${group}`);
   }
 }
 
@@ -83,14 +108,67 @@ export async function contactsGroups(args, jsonMode) {
   if (jsonMode) {
     outputResult(result, true);
   } else {
-    const groups = result.groups || result.data || [];
+    const groups = result.data?.groups || result.groups || result.data || [];
     if (groups.length === 0) {
       console.log("No contact groups found.");
       return;
     }
     formatTable(
-      ["ID", "Name", "Contacts"],
-      groups.map((g) => [g.id, g.name, g.contactCount || g.count || "-"])
+      ["ID", "Name", "Contacts", "Created"],
+      groups.map((g) => [
+        g.id,
+        g.name || "Untitled",
+        g.contactCount || g.count || 0,
+        g.createdAt ? new Date(g.createdAt).toLocaleDateString() : "-",
+      ])
     );
+    console.log(`\n${groups.length} group(s) found`);
+  }
+}
+
+export async function contactsExport(args, jsonMode) {
+  const group = args["--group"];
+  const format = args["--format"] || "csv";
+
+  const params = { format };
+  if (group) params.group = group;
+
+  const result = await apiRequest("GET", "/contacts/export", null, params);
+
+  if (jsonMode) {
+    outputResult(result, true);
+  } else {
+    const data = result.data || result;
+    if (data.downloadUrl) {
+      success(`Export ready: ${data.downloadUrl}`);
+    } else if (data.csv || typeof data === "string") {
+      console.log(data.csv || data);
+    } else {
+      success("Export initiated. Check your dashboard for the download link.");
+    }
+  }
+}
+
+export async function contactsDelete(args, jsonMode) {
+  const id = args["--id"];
+  const email = args["--email"];
+
+  if (!id && !email) {
+    console.error(`
+Usage: ses-cli contacts delete --id CONTACT_ID
+       ses-cli contacts delete --email EMAIL
+
+Permanently deletes a contact. This cannot be undone.
+`);
+    process.exit(1);
+  }
+
+  const path = id ? `/contacts/${id}` : `/contacts/by-email/${encodeURIComponent(email)}`;
+  const result = await apiRequest("DELETE", path);
+
+  if (jsonMode) {
+    outputResult(result, true);
+  } else {
+    success(`Contact ${id || email} deleted`);
   }
 }

package/src/commands/email.mjs

@@ -1,35 +1,64 @@
 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 emailSend(args, jsonMode) {
   const to = args["--to"];
   const subject = args["--subject"];
   const body = args["--body"];
-  const html = args["--html"];
+  const htmlFile = args["--html-file"] || args["--html"];
   const from = args["--from"];
-
-  if (!to || !subject || (!body && !html)) {
-    console.error("Usage: ses-cli email send --to EMAIL --subject SUBJECT --body TEXT [--html FILE] [--from SENDER]");
+  const fromName = args["--from-name"];
+  const provider = args["--provider"];
+  const schedule = args["--schedule"];
+  const templateId = args["--template"];
+
+  if (!to || (!subject && !templateId)) {
+    console.error(`
+Usage: ses-cli email send --to EMAIL --subject SUBJECT [options]
+
+Options:
+  --to          Recipient email address
+  --subject     Email subject line
+  --body        Plain text body
+  --html-file   Path to HTML file for email body
+  --from        Sender email address
+  --from-name   Sender display name
+  --provider    Provider ID to use (see: ses-cli providers list)
+  --template    Template ID to use (see: ses-cli templates list)
+  --schedule    Schedule send time (ISO 8601)
+
+Examples:
+  ses-cli email send --to user@example.com --subject "Hello" --body "Hi there!"
+  ses-cli email send --to user@example.com --subject "Newsletter" --html-file ./email.html
+  ses-cli email send --to user@example.com --subject "Promo" --template 12 --provider 3
+`);
     process.exit(1);
   }
 
-  const payload = { to, subject };
-  if (from) payload.from = from;
-
-  if (html) {
-    payload.html = readFileSync(html, "utf-8");
-  } else {
-    payload.body = body;
+  let htmlBody = body || "";
+  if (htmlFile) {
+    htmlBody = readFileSync(htmlFile, "utf-8");
   }
 
+  const payload = { to, subject };
+  if (htmlFile) payload.htmlBody = htmlBody;
+  else if (body) payload.body = body;
+  if (from) payload.fromEmail = from;
+  if (fromName) payload.fromName = fromName;
+  if (provider) payload.providerId = parseInt(provider);
+  if (schedule) payload.scheduledAt = schedule;
+  if (templateId) payload.templateId = parseInt(templateId);
+
   const result = await apiRequest("POST", "/email/send", payload);
 
   if (jsonMode) {
     outputResult(result, true);
   } else {
-    success(`Email sent to ${to}`);
-    if (result.messageId) console.log(`  Message ID: ${result.messageId}`);
+    success(`Email ${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}`);
   }
 }
 
@@ -37,42 +66,82 @@ export async function emailBulk(args, jsonMode) {
   const file = args["--file"];
   const subject = args["--subject"];
   const body = args["--body"];
-  const html = args["--html"];
+  const htmlFile = args["--html-file"] || args["--html"];
   const from = args["--from"];
-
-  if (!file || !subject || (!body && !html)) {
-    console.error("Usage: ses-cli email bulk --file contacts.csv --subject SUBJECT --body TEXT [--html FILE] [--from SENDER]");
-    console.error("\nCSV format: email (one email per line, or column header 'email')");
+  const fromName = args["--from-name"];
+  const provider = args["--provider"];
+  const delay = parseInt(args["--delay"] || "0");
+
+  if (!file || !subject) {
+    console.error(`
+Usage: ses-cli email bulk --file FILE --subject SUBJECT [options]
+
+Options:
+  --file        CSV file with email addresses (column: email or first column)
+  --subject     Email subject. Use [[ColumnName]] for personalization
+  --body        Plain text body. Use [[ColumnName]] for personalization
+  --html-file   Path to HTML template file. Use [[ColumnName]] for personalization
+  --from        Sender email address
+  --from-name   Sender display name
+  --provider    Provider ID to use
+  --delay       Delay between sends in ms (default: 0)
+
+Personalization:
+  Use [[First]], [[Last]], [[Email]], [[Custom1]], etc. in subject/body.
+  Column names are matched from your CSV headers.
+
+Examples:
+  ses-cli email bulk --file contacts.csv --subject "Hi [[First]]!" --html-file ./promo.html
+  ses-cli email bulk --file vip.csv --subject "Exclusive" --body "Hey [[First]]" --provider 5
+`);
     process.exit(1);
   }
 
+  let htmlBody = "";
+  if (htmlFile) {
+    htmlBody = readFileSync(htmlFile, "utf-8");
+  }
+
   const csvContent = readFileSync(file, "utf-8");
   const lines = csvContent.trim().split("\n");
-  const hasHeader = lines[0].toLowerCase().includes("email");
-  const emails = (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 emailIdx = headers.indexOf("email") !== -1 ? headers.indexOf("email") : 0;
+  const dataLines = lines.slice(1);
 
-  if (emails.length === 0) {
-    console.error("Error: No email addresses found in CSV file");
+  if (dataLines.length === 0) {
+    console.error("Error: No data rows found in CSV file");
     process.exit(1);
   }
 
-  const htmlContent = html ? readFileSync(html, "utf-8") : null;
-  console.log(`Sending to ${emails.length} recipients...`);
+  info(`Sending to ${dataLines.length} recipients...`);
 
   let sent = 0;
   let failed = 0;
   const errors = [];
 
-  for (const email of emails) {
+  for (const line of dataLines) {
+    const cols = line.split(",").map(c => c.trim().replace(/"/g, ""));
+    const email = cols[emailIdx];
+    if (!email) continue;
+
+    let personalizedSubject = subject;
+    let personalizedBody = htmlBody || body || "";
+    headers.forEach((header, idx) => {
+      const regex = new RegExp(`\\[\\[${header}\\]\\]`, "gi");
+      personalizedSubject = personalizedSubject.replace(regex, cols[idx] || "");
+      personalizedBody = personalizedBody.replace(regex, cols[idx] || "");
+    });
+
     try {
-      const payload = { to: email, subject };
-      if (from) payload.from = from;
-      if (htmlContent) payload.html = htmlContent;
-      else payload.body = body;
+      const payload = { to: email, subject: personalizedSubject };
+      if (htmlFile) payload.htmlBody = personalizedBody;
+      else payload.body = personalizedBody;
+      if (from) payload.fromEmail = from;
+      if (fromName) payload.fromName = fromName;
+      if (provider) payload.providerId = parseInt(provider);
       await apiRequest("POST", "/email/send", payload);
       sent++;
+      if (delay > 0) await new Promise(r => setTimeout(r, delay));
     } catch {
       failed++;
       errors.push(email);
@@ -80,11 +149,11 @@ export async function emailBulk(args, jsonMode) {
   }
 
   if (jsonMode) {
-    outputResult({ sent, failed, total: emails.length, errors }, true);
+    outputResult({ sent, failed, total: dataLines.length, errors }, true);
   } else {
-    success(`Bulk email complete: ${sent} sent, ${failed} failed out of ${emails.length}`);
+    success(`Bulk email complete: ${sent} sent, ${failed} failed out of ${dataLines.length}`);
     if (errors.length > 0) {
-      console.log(`  Failed emails: ${errors.slice(0, 5).join(", ")}${errors.length > 5 ? "..." : ""}`);
+      console.log(`  Failed: ${errors.slice(0, 5).join(", ")}${errors.length > 5 ? ` +${errors.length - 5} more` : ""}`);
     }
   }
 }
@@ -92,23 +161,28 @@ export async function emailBulk(args, jsonMode) {
 export async function emailHistory(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", "/email/history", null, { limit, page });
+  const result = await apiRequest("GET", "/email/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 email messages found.");
       return;
     }
     formatTable(
-      ["To", "Subject", "Status", "Date"],
+      ["To", "Subject", "Status", "Provider", "Date"],
       messages.map((m) => [
         m.to || m.recipient,
-        (m.subject || "").slice(0, 30),
+        (m.subject || "").slice(0, 25),
         m.status || "sent",
+        m.provider || "-",
         new Date(m.createdAt || m.sentAt).toLocaleString(),
       ])
     );

package/src/commands/providers.mjs

@@ -0,0 +1,50 @@
+import { apiRequest } from "../api.mjs";
+import { formatTable, outputResult, success } from "../output.mjs";
+
+export async function providersList(args, jsonMode) {
+  const type = args["--type"]; // sms, email, or all
+
+  const params = {};
+  if (type) params.type = type;
+
+  const result = await apiRequest("GET", "/providers", null, params);
+
+  if (jsonMode) {
+    outputResult(result, true);
+  } else {
+    const providers = result.data?.providers || result.providers || result.data || [];
+    if (providers.length === 0) {
+      console.log("No providers configured. Set up providers in your SESender dashboard.");
+      return;
+    }
+    formatTable(
+      ["ID", "Name", "Type", "Provider", "Status"],
+      providers.map((p) => [
+        p.id,
+        p.name || p.providerType,
+        p.type || p.providerType,
+        p.providerType,
+        p.isActive ? "Active" : "Inactive",
+      ])
+    );
+    console.log(`\n${providers.length} provider(s) found`);
+  }
+}
+
+export async function providersBalance(args, jsonMode) {
+  const result = await apiRequest("GET", "/providers/balance");
+
+  if (jsonMode) {
+    outputResult(result, true);
+  } else {
+    const balances = result.data || result;
+    if (Array.isArray(balances)) {
+      formatTable(
+        ["Provider", "Balance", "Currency"],
+        balances.map((b) => [b.provider || b.name, b.balance || "N/A", b.currency || "USD"])
+      );
+    } else {
+      console.log(JSON.stringify(balances, null, 2));
+    }
+  }
+}

package/src/commands/schedule.mjs

@@ -0,0 +1,52 @@
+import { apiRequest } from "../api.mjs";
+import { formatTable, outputResult, success } from "../output.mjs";
+
+export async function scheduleList(args, jsonMode) {
+  const status = args["--status"];
+  const params = {};
+  if (status) params.status = status;
+
+  const result = await apiRequest("GET", "/scheduled", null, params);
+
+  if (jsonMode) {
+    outputResult(result, true);
+  } else {
+    const items = result.data?.scheduled || result.scheduled || result.data || [];
+    if (items.length === 0) {
+      console.log("No scheduled messages found.");
+      return;
+    }
+    formatTable(
+      ["ID", "Type", "To", "Scheduled For", "Status"],
+      items.map((s) => [
+        s.id,
+        s.type || "email",
+        (s.to || s.recipient || "").slice(0, 20),
+        s.scheduledAt ? new Date(s.scheduledAt).toLocaleString() : "-",
+        s.status || "pending",
+      ])
+    );
+    console.log(`\n${items.length} scheduled message(s)`);
+  }
+}
+
+export async function scheduleCancel(args, jsonMode) {
+  const id = args["--id"];
+
+  if (!id) {
+    console.error(`
+Usage: ses-cli schedule cancel --id SCHEDULE_ID
+
+Cancels a scheduled message before it is sent.
+`);
+    process.exit(1);
+  }
+
+  const result = await apiRequest("POST", `/scheduled/${id}/cancel`);
+
+  if (jsonMode) {
+    outputResult(result, true);
+  } else {
+    success(`Scheduled message ${id} cancelled`);
+  }
+}

package/src/commands/seedcheck.mjs

@@ -0,0 +1,97 @@
+import { readFileSync } from "fs";
+import { apiRequest } from "../api.mjs";
+import { formatTable, outputResult, success, info } from "../output.mjs";
+
+export async function seedCheck(args, jsonMode) {
+  const file = args["--file"];
+  const emails = args["--emails"];
+  const words = args["--words"] || args["--seed-words"];
+
+  if ((!file && !emails) || !words) {
+    console.error(`
+Usage: ses-cli seed-check --emails EMAILS --words WORDS
+       ses-cli seed-check --file FILE --words WORDS
+
+Options:
+  --emails      Comma-separated list of emails to check
+  --file        CSV file with emails (column: email or first column)
+  --words       Comma-separated seed words to check against
+  --seed-words  Alias for --words
+
+Description:
+  Checks emails against your seed word database to identify risky
+  addresses that may be spam traps or seed addresses.
+
+Examples:
+  ses-cli seed-check --emails "user@test.com,info@example.com" --words "trap,seed,monitor"
+  ses-cli seed-check --file contacts.csv --words "spamtrap,honeypot,seedlist"
+`);
+    process.exit(1);
+  }
+
+  let emailList = [];
+  if (file) {
+    const csvContent = readFileSync(file, "utf-8");
+    const lines = csvContent.trim().split("\n");
+    const headers = lines[0].toLowerCase().split(",").map(h => h.trim().replace(/"/g, ""));
+    const emailIdx = headers.indexOf("email") !== -1 ? headers.indexOf("email") : 0;
+    emailList = lines.slice(1)
+      .map(l => l.split(",")[emailIdx]?.trim().replace(/"/g, ""))
+      .filter(Boolean);
+  } else {
+    emailList = emails.split(",").map(e => e.trim()).filter(Boolean);
+  }
+
+  const seedWords = words.split(",").map(w => w.trim()).filter(Boolean);
+
+  if (emailList.length === 0) {
+    console.error("Error: No emails provided");
+    process.exit(1);
+  }
+
+  if (emailList.length > 500) {
+    console.error("Error: Maximum 500 emails per request");
+    process.exit(1);
+  }
+
+  info(`Checking ${emailList.length} emails against ${seedWords.length} seed words...`);
+
+  const result = await apiRequest("POST", "/seed-check", {
+    emails: emailList,
+    seedWords: seedWords,
+  });
+
+  if (jsonMode) {
+    outputResult(result, true);
+  } else {
+    const data = result.data || result;
+    const results = data.results || [];
+    const risky = results.filter(r => r.isRisky || r.riskScore > 50);
+    const safe = results.filter(r => !r.isRisky && (r.riskScore || 0) <= 50);
+
+    success(`Seed check complete: ${safe.length} safe, ${risky.length} risky`);
+
+    if (risky.length > 0) {
+      console.log("\n  Risky emails:");
+      formatTable(
+        ["Email", "Risk Score", "Source"],
+        risky.map(r => [r.email, `${r.riskScore || 100}%`, r.source || "database"])
+      );
+    }
+
+    if (data.cost) console.log(`\n  Cost: €${data.cost.toFixed(2)}`);
+    if (data.balance) console.log(`  Remaining balance: €${data.balance.toFixed(2)}`);
+  }
+}
+
+export async function seedBalance(args, jsonMode) {
+  const result = await apiRequest("GET", "/seed-check/balance");
+
+  if (jsonMode) {
+    outputResult(result, true);
+  } else {
+    const data = result.data || result;
+    console.log(`  Balance: €${(data.balance || 0).toFixed(2)}`);
+    console.log(`  Rate: €${(data.rate || 0.01).toFixed(4)} per email`);
+  }
+}