npm - mails - Versions diffs - 0.2.0 → 1.0.1 - Mend

mails 0.2.0 → 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/dist/cli.js ADDED Viewed

@@ -0,0 +1,668 @@
+#!/usr/bin/env bun
+// @bun
+// src/core/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".mails");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var DEFAULT_CONFIG = {
+  mode: "hosted",
+  domain: "mails.dev",
+  mailbox: "",
+  send_provider: "resend",
+  storage_provider: "sqlite"
+};
+function ensureDir() {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+}
+function loadConfig() {
+  ensureDir();
+  if (!existsSync(CONFIG_FILE)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  const raw = readFileSync(CONFIG_FILE, "utf-8");
+  return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+}
+function saveConfig(config) {
+  ensureDir();
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + `
+`);
+}
+function getConfigValue(key) {
+  const config = { ...loadConfig() };
+  return config[key];
+}
+function setConfigValue(key, value) {
+  const config = { ...loadConfig() };
+  config[key] = value;
+  saveConfig(config);
+}
+// src/providers/send/resend.ts
+function createResendProvider(apiKey) {
+  return {
+    name: "resend",
+    async send(options) {
+      const body = {
+        from: options.from,
+        to: options.to,
+        subject: options.subject
+      };
+      if (options.text)
+        body.text = options.text;
+      if (options.html)
+        body.html = options.html;
+      if (options.replyTo)
+        body.reply_to = options.replyTo;
+      const res = await fetch("https://api.resend.com/emails", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) {
+        const err = await res.json();
+        throw new Error(`Resend error: ${err.message}`);
+      }
+      const data = await res.json();
+      return { id: data.id, provider: "resend" };
+    }
+  };
+}
+// src/core/send.ts
+function resolveProvider() {
+  const config = loadConfig();
+  switch (config.send_provider) {
+    case "resend": {
+      if (!config.resend_api_key) {
+        throw new Error("resend_api_key not configured. Run: mails config set resend_api_key <key>");
+      }
+      return createResendProvider(config.resend_api_key);
+    }
+    default:
+      throw new Error(`Unknown send provider: ${config.send_provider}`);
+  }
+}
+async function send(options) {
+  const config = loadConfig();
+  const provider = resolveProvider();
+  const from = options.from ?? config.default_from;
+  if (!from) {
+    throw new Error('No "from" address. Set default_from or pass --from');
+  }
+  const to = Array.isArray(options.to) ? options.to : [options.to];
+  if (!options.text && !options.html) {
+    throw new Error("Either text or html body is required");
+  }
+  return provider.send({
+    from,
+    to,
+    subject: options.subject,
+    text: options.text,
+    html: options.html,
+    replyTo: options.replyTo
+  });
+}
+// src/cli/commands/send.ts
+function parseArgs(args) {
+  const result = {};
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const value = args[i + 1];
+      if (value && !value.startsWith("--")) {
+        result[key] = value;
+        i++;
+      }
+    }
+  }
+  return result;
+}
+async function sendCommand(args) {
+  const opts = parseArgs(args);
+  if (!opts["to"]) {
+    console.error("Usage: mails send --to <email> --subject <subject> --body <text> [--html <html>] [--from <from>] [--reply-to <email>]");
+    process.exit(1);
+  }
+  if (!opts["subject"]) {
+    console.error("Missing --subject");
+    process.exit(1);
+  }
+  if (!opts["body"] && !opts["html"]) {
+    console.error("Missing --body or --html");
+    process.exit(1);
+  }
+  const result = await send({
+    from: opts["from"],
+    to: opts["to"],
+    subject: opts["subject"],
+    text: opts["body"],
+    html: opts["html"],
+    replyTo: opts["reply-to"]
+  });
+  console.log(`Sent via ${result.provider} (id: ${result.id})`);
+}
+// src/providers/storage/sqlite.ts
+import { Database } from "bun:sqlite";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS emails (
+  id TEXT PRIMARY KEY,
+  mailbox TEXT NOT NULL,
+  from_address TEXT NOT NULL,
+  from_name TEXT DEFAULT '',
+  to_address TEXT NOT NULL,
+  subject TEXT DEFAULT '',
+  body_text TEXT DEFAULT '',
+  body_html TEXT DEFAULT '',
+  code TEXT,
+  headers TEXT DEFAULT '{}',
+  metadata TEXT DEFAULT '{}',
+  direction TEXT NOT NULL CHECK (direction IN ('inbound', 'outbound')),
+  status TEXT DEFAULT 'received' CHECK (status IN ('received', 'sent', 'failed', 'queued')),
+  received_at TEXT NOT NULL,
+  created_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_emails_mailbox ON emails(mailbox, received_at DESC);
+CREATE INDEX IF NOT EXISTS idx_emails_code ON emails(mailbox) WHERE code IS NOT NULL;
+`;
+function createSqliteProvider(dbPath) {
+  const dir = join2(homedir2(), ".mails");
+  if (!existsSync2(dir))
+    mkdirSync2(dir, { recursive: true });
+  const path = dbPath ?? join2(dir, "mails.db");
+  let db;
+  return {
+    name: "sqlite",
+    async init() {
+      db = new Database(path);
+      db.exec("PRAGMA journal_mode=WAL;");
+      db.exec(SCHEMA);
+    },
+    async saveEmail(email) {
+      db.prepare(`
+        INSERT OR REPLACE INTO emails (id, mailbox, from_address, from_name, to_address, subject, body_text, body_html, code, headers, metadata, direction, status, received_at, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(email.id, email.mailbox, email.from_address, email.from_name, email.to_address, email.subject, email.body_text, email.body_html, email.code, JSON.stringify(email.headers), JSON.stringify(email.metadata), email.direction, email.status, email.received_at, email.created_at);
+    },
+    async getEmails(mailbox, options) {
+      const limit = options?.limit ?? 20;
+      const offset = options?.offset ?? 0;
+      let query = "SELECT * FROM emails WHERE mailbox = ?";
+      const params = [mailbox];
+      if (options?.direction) {
+        query += " AND direction = ?";
+        params.push(options.direction);
+      }
+      query += " ORDER BY received_at DESC LIMIT ? OFFSET ?";
+      params.push(limit, offset);
+      const rows = db.prepare(query).all(...params);
+      return rows.map(rowToEmail);
+    },
+    async getEmail(id) {
+      const row = db.prepare("SELECT * FROM emails WHERE id = ?").get(id);
+      return row ? rowToEmail(row) : null;
+    },
+    async getCode(mailbox, options) {
+      const timeout = (options?.timeout ?? 30) * 1000;
+      const since = options?.since;
+      const deadline = Date.now() + timeout;
+      while (Date.now() < deadline) {
+        let query = "SELECT code, from_address, subject FROM emails WHERE mailbox = ? AND code IS NOT NULL";
+        const params = [mailbox];
+        if (since) {
+          query += " AND received_at > ?";
+          params.push(since);
+        }
+        query += " ORDER BY received_at DESC LIMIT 1";
+        const row = db.prepare(query).get(...params);
+        if (row) {
+          return { code: row.code, from: row.from_address, subject: row.subject };
+        }
+        await new Promise((r) => setTimeout(r, 1000));
+      }
+      return null;
+    }
+  };
+}
+function rowToEmail(row) {
+  return {
+    id: row.id,
+    mailbox: row.mailbox,
+    from_address: row.from_address,
+    from_name: row.from_name ?? "",
+    to_address: row.to_address,
+    subject: row.subject ?? "",
+    body_text: row.body_text ?? "",
+    body_html: row.body_html ?? "",
+    code: row.code ?? null,
+    headers: safeJsonParse(row.headers, {}),
+    metadata: safeJsonParse(row.metadata, {}),
+    direction: row.direction,
+    status: row.status,
+    received_at: row.received_at,
+    created_at: row.created_at
+  };
+}
+function safeJsonParse(str, fallback) {
+  if (!str)
+    return fallback;
+  try {
+    return JSON.parse(str);
+  } catch {
+    return fallback;
+  }
+}
+// src/providers/storage/db9.ts
+var SCHEMA2 = `
+CREATE TABLE IF NOT EXISTS emails (
+  id TEXT PRIMARY KEY,
+  mailbox TEXT NOT NULL,
+  from_address TEXT NOT NULL,
+  from_name TEXT DEFAULT '',
+  to_address TEXT NOT NULL,
+  subject TEXT DEFAULT '',
+  body_text TEXT DEFAULT '',
+  body_html TEXT DEFAULT '',
+  code TEXT,
+  headers JSONB DEFAULT '{}',
+  metadata JSONB DEFAULT '{}',
+  direction TEXT NOT NULL CHECK (direction IN ('inbound', 'outbound')),
+  status TEXT DEFAULT 'received' CHECK (status IN ('received', 'sent', 'failed', 'queued')),
+  received_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+  created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX IF NOT EXISTS idx_emails_mailbox ON emails(mailbox, received_at DESC);
+CREATE INDEX IF NOT EXISTS idx_emails_code ON emails(mailbox) WHERE code IS NOT NULL;
+`;
+function createDb9Provider(token, databaseId) {
+  const baseUrl = "https://api.db9.ai";
+  async function sql(query) {
+    const res = await fetch(`${baseUrl}/customer/databases/${databaseId}/sql`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ query })
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`db9 error (${res.status}): ${text}`);
+    }
+    return await res.json();
+  }
+  function rowsToEmails(result) {
+    return result.rows.map((row) => {
+      const obj = {};
+      result.columns.forEach((col, i) => {
+        obj[col] = row[i];
+      });
+      return {
+        id: obj.id,
+        mailbox: obj.mailbox,
+        from_address: obj.from_address,
+        from_name: obj.from_name ?? "",
+        to_address: obj.to_address,
+        subject: obj.subject ?? "",
+        body_text: obj.body_text ?? "",
+        body_html: obj.body_html ?? "",
+        code: obj.code ?? null,
+        headers: typeof obj.headers === "string" ? JSON.parse(obj.headers) : obj.headers ?? {},
+        metadata: typeof obj.metadata === "string" ? JSON.parse(obj.metadata) : obj.metadata ?? {},
+        direction: obj.direction,
+        status: obj.status,
+        received_at: obj.received_at,
+        created_at: obj.created_at
+      };
+    });
+  }
+  return {
+    name: "db9",
+    async init() {
+      await sql(SCHEMA2);
+    },
+    async saveEmail(email) {
+      const esc = (s) => s.replace(/'/g, "''");
+      await sql(`
+        INSERT INTO emails (id, mailbox, from_address, from_name, to_address, subject, body_text, body_html, code, headers, metadata, direction, status, received_at, created_at)
+        VALUES (
+          '${esc(email.id)}', '${esc(email.mailbox)}', '${esc(email.from_address)}', '${esc(email.from_name)}',
+          '${esc(email.to_address)}', '${esc(email.subject)}', '${esc(email.body_text)}', '${esc(email.body_html)}',
+          ${email.code ? `'${esc(email.code)}'` : "NULL"},
+          '${esc(JSON.stringify(email.headers))}'::jsonb,
+          '${esc(JSON.stringify(email.metadata))}'::jsonb,
+          '${esc(email.direction)}', '${esc(email.status)}',
+          '${esc(email.received_at)}', '${esc(email.created_at)}'
+        )
+        ON CONFLICT (id) DO UPDATE SET
+          status = EXCLUDED.status,
+          metadata = EXCLUDED.metadata
+      `);
+    },
+    async getEmails(mailbox, options) {
+      const limit = options?.limit ?? 20;
+      const offset = options?.offset ?? 0;
+      const esc = (s) => s.replace(/'/g, "''");
+      let query = `SELECT * FROM emails WHERE mailbox = '${esc(mailbox)}'`;
+      if (options?.direction) {
+        query += ` AND direction = '${esc(options.direction)}'`;
+      }
+      query += ` ORDER BY received_at DESC LIMIT ${limit} OFFSET ${offset}`;
+      const result = await sql(query);
+      return rowsToEmails(result);
+    },
+    async getEmail(id) {
+      const esc = (s) => s.replace(/'/g, "''");
+      const result = await sql(`SELECT * FROM emails WHERE id = '${esc(id)}' LIMIT 1`);
+      const emails = rowsToEmails(result);
+      return emails[0] ?? null;
+    },
+    async getCode(mailbox, options) {
+      const timeout = (options?.timeout ?? 30) * 1000;
+      const since = options?.since;
+      const esc = (s) => s.replace(/'/g, "''");
+      const deadline = Date.now() + timeout;
+      while (Date.now() < deadline) {
+        let query = `SELECT code, from_address, subject FROM emails WHERE mailbox = '${esc(mailbox)}' AND code IS NOT NULL`;
+        if (since) {
+          query += ` AND received_at > '${esc(since)}'`;
+        }
+        query += " ORDER BY received_at DESC LIMIT 1";
+        const result = await sql(query);
+        if (result.row_count > 0) {
+          const row = result.rows[0];
+          const codeIdx = result.columns.indexOf("code");
+          const fromIdx = result.columns.indexOf("from_address");
+          const subIdx = result.columns.indexOf("subject");
+          return {
+            code: row[codeIdx],
+            from: row[fromIdx],
+            subject: row[subIdx]
+          };
+        }
+        await new Promise((r) => setTimeout(r, 2000));
+      }
+      return null;
+    }
+  };
+}
+// src/core/storage.ts
+var _provider = null;
+async function getStorage() {
+  if (_provider)
+    return _provider;
+  const config = loadConfig();
+  switch (config.storage_provider) {
+    case "db9": {
+      if (!config.db9_token) {
+        throw new Error("db9_token not configured. Run: mails config set db9_token <token>");
+      }
+      if (!config.db9_database_id) {
+        throw new Error("db9_database_id not configured. Run: mails config set db9_database_id <id>");
+      }
+      _provider = createDb9Provider(config.db9_token, config.db9_database_id);
+      break;
+    }
+    case "sqlite":
+    default: {
+      _provider = createSqliteProvider();
+      break;
+    }
+  }
+  await _provider.init();
+  return _provider;
+}
+// src/core/receive.ts
+async function getInbox(mailbox, options) {
+  const storage = await getStorage();
+  return storage.getEmails(mailbox, options);
+}
+async function getEmail(id) {
+  const storage = await getStorage();
+  return storage.getEmail(id);
+}
+async function waitForCode(mailbox, options) {
+  const storage = await getStorage();
+  return storage.getCode(mailbox, options);
+}
+// src/cli/commands/inbox.ts
+function parseArgs2(args) {
+  const result = {};
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const value = args[i + 1];
+      if (value && !value.startsWith("--")) {
+        result[key] = value;
+        i++;
+      }
+    } else if (!result._positional) {
+      result._positional = arg;
+    }
+  }
+  return result;
+}
+async function inboxCommand(args) {
+  const opts = parseArgs2(args);
+  if (opts._positional) {
+    const email = await getEmail(opts._positional);
+    if (!email) {
+      console.error(`Email not found: ${opts._positional}`);
+      process.exit(1);
+    }
+    console.log(`From: ${email.from_name ? `${email.from_name} <${email.from_address}>` : email.from_address}`);
+    console.log(`To: ${email.to_address}`);
+    console.log(`Subject: ${email.subject}`);
+    console.log(`Date: ${email.received_at}`);
+    if (email.code)
+      console.log(`Code: ${email.code}`);
+    console.log(`Status: ${email.status}`);
+    console.log("---");
+    console.log(email.body_text || "(no text body)");
+    return;
+  }
+  const config = loadConfig();
+  const mailbox = opts.mailbox ?? config.mailbox;
+  if (!mailbox) {
+    console.error("No mailbox specified. Use --mailbox <address> or set: mails config set mailbox <address>");
+    process.exit(1);
+  }
+  const limit = opts.limit ? parseInt(opts.limit) : 20;
+  const emails = await getInbox(mailbox, { limit });
+  if (emails.length === 0) {
+    console.log("No emails found.");
+    return;
+  }
+  for (const email of emails) {
+    const code = email.code ? ` [${email.code}]` : "";
+    const from = email.from_name || email.from_address;
+    console.log(`${email.id.slice(0, 8)}  ${email.received_at.slice(0, 16)}  ${from.padEnd(24).slice(0, 24)}  ${email.subject.slice(0, 40)}${code}`);
+  }
+}
+// src/cli/commands/code.ts
+function parseArgs3(args) {
+  const result = {};
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const value = args[i + 1];
+      if (value && !value.startsWith("--")) {
+        result[key] = value;
+        i++;
+      }
+    }
+  }
+  return result;
+}
+async function codeCommand(args) {
+  const opts = parseArgs3(args);
+  const config = loadConfig();
+  const mailbox = opts.to ?? config.mailbox;
+  if (!mailbox) {
+    console.error("No mailbox specified. Use --to <address> or set: mails config set mailbox <address>");
+    process.exit(1);
+  }
+  const timeout = opts.timeout ? parseInt(opts.timeout) : 30;
+  const since = opts.since ?? new Date().toISOString();
+  console.error(`Waiting for verification code to ${mailbox} (timeout: ${timeout}s)...`);
+  const result = await waitForCode(mailbox, { timeout, since });
+  if (result) {
+    console.log(result.code);
+    console.error(`From: ${result.from}`);
+    console.error(`Subject: ${result.subject}`);
+  } else {
+    console.error("No code received within timeout.");
+    process.exit(1);
+  }
+}
+// src/cli/commands/config.ts
+async function configCommand(args) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "set": {
+      const key = args[1];
+      const value = args[2];
+      if (!key || !value) {
+        console.error("Usage: mails config set <key> <value>");
+        process.exit(1);
+      }
+      setConfigValue(key, value);
+      console.log(`Set ${key} = ${value}`);
+      break;
+    }
+    case "get": {
+      const key = args[1];
+      if (!key) {
+        console.error("Usage: mails config get <key>");
+        process.exit(1);
+      }
+      const value = getConfigValue(key);
+      if (value !== undefined) {
+        console.log(value);
+      } else {
+        console.error(`Key "${key}" not set`);
+        process.exit(1);
+      }
+      break;
+    }
+    case "path": {
+      console.log(CONFIG_FILE);
+      break;
+    }
+    default: {
+      const config = loadConfig();
+      console.log(JSON.stringify(config, null, 2));
+      break;
+    }
+  }
+}
+// src/cli/commands/help.ts
+function helpCommand() {
+  console.log(`
+mails - Email infrastructure for AI agents
+Usage:
+  mails <command> [options]
+Commands:
+  send          Send an email
+  inbox         List received emails
+  code          Wait for a verification code
+  config        View or modify configuration
+  setup         Interactive setup wizard (coming soon)
+  help          Show this help message
+  version       Show version
+Send:
+  mails send --to <email> --subject <subject> --body <text>
+  mails send --to <email> --subject <subject> --html <html>
+  mails send --from "Name <email>" --to <email> --subject <subject> --body <text>
+Inbox:
+  mails inbox                           List recent emails
+  mails inbox --mailbox <address>       List emails for a specific mailbox
+  mails inbox <id>                      Show email details
+Code:
+  mails code --to <address>             Wait for a verification code
+  mails code --to <address> --timeout 60
+Config:
+  mails config                    Show current config
+  mails config set <key> <value>  Set a config value
+  mails config get <key>          Get a config value
+  mails config path               Show config file path
+Config keys:
+  mode              hosted | selfhosted
+  domain            Your email domain
+  mailbox           Your mailbox address
+  send_provider     resend (default)
+  storage_provider  sqlite | db9
+  resend_api_key    Resend API key
+  db9_token         db9.ai token
+  db9_database_id   db9.ai database ID
+  default_from      Default sender address
+https://mails.dev
+`.trim());
+}
+// src/cli/index.ts
+var args = process.argv.slice(2);
+var command = args[0];
+async function main() {
+  switch (command) {
+    case "send":
+      await sendCommand(args.slice(1));
+      break;
+    case "inbox":
+      await inboxCommand(args.slice(1));
+      break;
+    case "code":
+      await codeCommand(args.slice(1));
+      break;
+    case "config":
+      await configCommand(args.slice(1));
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+    case undefined:
+      helpCommand();
+      break;
+    case "version":
+    case "--version":
+    case "-v":
+      console.log("mails v1.0.1");
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      helpCommand();
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});