@happyvertical/email 0.74.8

package/dist/index.js

@@ -0,0 +1,2165 @@
+import { google } from "googleapis";
+import { simpleParser } from "mailparser";
+import { createLogger } from "@happyvertical/logger";
+import { ImapFlow } from "imapflow";
+import Pop3Command from "node-pop3";
+import nodemailer from "nodemailer";
+class EmailError extends Error {
+  code;
+  provider;
+  cause;
+  constructor(message, code, provider, cause) {
+    super(message);
+    this.name = "EmailError";
+    this.code = code;
+    this.provider = provider;
+    this.cause = cause;
+  }
+}
+class ConnectionError extends EmailError {
+  constructor(message, provider, cause) {
+    super(message, "CONNECTION_ERROR", provider, cause);
+    this.name = "ConnectionError";
+  }
+}
+class TimeoutError extends EmailError {
+  constructor(message, provider, cause) {
+    super(message, "TIMEOUT_ERROR", provider, cause);
+    this.name = "TimeoutError";
+  }
+}
+class AuthenticationError extends EmailError {
+  constructor(message, provider, cause) {
+    super(message, "AUTHENTICATION_ERROR", provider, cause);
+    this.name = "AuthenticationError";
+  }
+}
+class AuthorizationError extends EmailError {
+  constructor(message, provider, cause) {
+    super(message, "AUTHORIZATION_ERROR", provider, cause);
+    this.name = "AuthorizationError";
+  }
+}
+class MessageNotFoundError extends EmailError {
+  messageId;
+  constructor(messageId, provider) {
+    super(`Message not found: ${messageId}`, "MESSAGE_NOT_FOUND", provider);
+    this.name = "MessageNotFoundError";
+    this.messageId = messageId;
+  }
+}
+class InvalidMessageError extends EmailError {
+  constructor(message, provider, cause) {
+    super(message, "INVALID_MESSAGE", provider, cause);
+    this.name = "InvalidMessageError";
+  }
+}
+class FolderNotFoundError extends EmailError {
+  folder;
+  constructor(folder, provider) {
+    super(`Folder not found: ${folder}`, "FOLDER_NOT_FOUND", provider);
+    this.name = "FolderNotFoundError";
+    this.folder = folder;
+  }
+}
+class FolderExistsError extends EmailError {
+  folder;
+  constructor(folder, provider) {
+    super(`Folder already exists: ${folder}`, "FOLDER_EXISTS", provider);
+    this.name = "FolderExistsError";
+    this.folder = folder;
+  }
+}
+class SendError extends EmailError {
+  accepted;
+  rejected;
+  constructor(message, accepted, rejected, provider, cause) {
+    super(message, "SEND_ERROR", provider, cause);
+    this.name = "SendError";
+    this.accepted = accepted;
+    this.rejected = rejected;
+  }
+}
+class AttachmentError extends EmailError {
+  filename;
+  constructor(message, filename, provider, cause) {
+    super(message, "ATTACHMENT_ERROR", provider, cause);
+    this.name = "AttachmentError";
+    this.filename = filename;
+  }
+}
+class BaseEmailClient {
+  config;
+  logger;
+  connected = false;
+  constructor(config) {
+    this.config = this.validateConfig(config);
+    this.logger = config.logger || createLogger({ level: "info" });
+  }
+  // ========================================================================
+  // Connection management
+  // ========================================================================
+  isConnected() {
+    return this.connected;
+  }
+  // ========================================================================
+  // Validation helpers
+  // ========================================================================
+  validateConfig(config) {
+    if (!config.type) {
+      throw new EmailError("Email client type is required", "INVALID_CONFIG");
+    }
+    return config;
+  }
+  validateEmail(email) {
+    if (!email.address) {
+      throw new InvalidMessageError(
+        "Email address is required",
+        this.getAdapter()
+      );
+    }
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(email.address)) {
+      throw new InvalidMessageError(
+        `Invalid email address: ${email.address}`,
+        this.getAdapter()
+      );
+    }
+  }
+  validateMessage(message) {
+    if (!message.from) {
+      throw new InvalidMessageError(
+        "Message must have a sender (from)",
+        this.getAdapter()
+      );
+    }
+    this.validateEmail(message.from);
+    if (!message.to || message.to.length === 0) {
+      throw new InvalidMessageError(
+        "Message must have at least one recipient (to)",
+        this.getAdapter()
+      );
+    }
+    for (const recipient of message.to) {
+      this.validateEmail(recipient);
+    }
+    if (message.cc) {
+      for (const recipient of message.cc) {
+        this.validateEmail(recipient);
+      }
+    }
+    if (message.bcc) {
+      for (const recipient of message.bcc) {
+        this.validateEmail(recipient);
+      }
+    }
+    if (!message.subject) {
+      throw new InvalidMessageError(
+        "Message must have a subject",
+        this.getAdapter()
+      );
+    }
+    if (!message.text && !message.html) {
+      throw new InvalidMessageError(
+        "Message must have either text or HTML content",
+        this.getAdapter()
+      );
+    }
+  }
+  // ========================================================================
+  // Error mapping
+  // ========================================================================
+  mapError(error) {
+    if (error instanceof EmailError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      return new EmailError(
+        error.message,
+        "UNKNOWN_ERROR",
+        this.getAdapter(),
+        error
+      );
+    }
+    return new EmailError(String(error), "UNKNOWN_ERROR", this.getAdapter());
+  }
+  // ========================================================================
+  // Utility methods
+  // ========================================================================
+  normalizeMessageIds(messageId) {
+    return Array.isArray(messageId) ? messageId : [messageId];
+  }
+  debug(message, data) {
+    if (this.config.debug) {
+      this.logger.debug(message, data);
+    }
+  }
+}
+class GmailAdapter extends BaseEmailClient {
+  gmail = null;
+  options;
+  auth = null;
+  constructor(options) {
+    super({
+      type: "gmail",
+      debug: options.debug
+    });
+    this.options = options;
+  }
+  // ========================================================================
+  // Connection management
+  // ========================================================================
+  async connect() {
+    try {
+      const auth = new google.auth.OAuth2(
+        this.options.auth.clientId,
+        this.options.auth.clientSecret
+      );
+      auth.setCredentials({
+        refresh_token: this.options.auth.refreshToken,
+        access_token: this.options.auth.accessToken
+      });
+      this.auth = auth;
+      this.gmail = google.gmail({ version: "v1", auth });
+      await this.gmail.users.getProfile({ userId: this.getUserId() });
+      this.connected = true;
+      this.debug("Connected to Gmail API");
+    } catch (error) {
+      throw this.mapGmailError(error);
+    }
+  }
+  async disconnect() {
+    this.gmail = null;
+    this.auth = null;
+    this.connected = false;
+    this.debug("Disconnected from Gmail API");
+  }
+  // ========================================================================
+  // Send operations
+  // ========================================================================
+  async send(message, options) {
+    this.ensureConnected();
+    this.validateMessage(message);
+    try {
+      const email = this.buildRFC2822Message(message, options);
+      const encodedEmail = Buffer.from(email).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+      const response = await this.gmail?.users.messages.send({
+        userId: this.getUserId(),
+        requestBody: {
+          raw: encodedEmail
+        }
+      });
+      if (!response) {
+        throw new SendError("Failed to send message", [], [], "gmail");
+      }
+      return {
+        messageId: response.data.id || "",
+        accepted: message.to.map((addr) => addr.address),
+        rejected: [],
+        response: `Message sent: ${response.data.id}`
+      };
+    } catch (error) {
+      throw this.mapGmailError(error);
+    }
+  }
+  // ========================================================================
+  // Receive operations
+  // ========================================================================
+  async fetch(options) {
+    this.ensureConnected();
+    try {
+      const query = this.buildGmailQuery(options);
+      let labelIds = options?.labelIds;
+      if (options?.folder && !labelIds) {
+        labelIds = [options.folder];
+      }
+      let listResponse;
+      try {
+        listResponse = await this.gmail?.users.messages.list({
+          userId: this.getUserId(),
+          q: query,
+          labelIds,
+          maxResults: options?.maxResults || options?.limit || 100
+        });
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("Invalid label")) {
+          return [];
+        }
+        throw error;
+      }
+      if (!listResponse) {
+        return [];
+      }
+      const messageIds = listResponse.data.messages || [];
+      if (messageIds.length === 0) {
+        return [];
+      }
+      const messages = [];
+      for (const msgId of messageIds) {
+        if (!msgId.id) continue;
+        try {
+          const message = await this.getMessage(msgId.id);
+          messages.push(message);
+          if (options?.limit && messages.length >= options.limit) {
+            break;
+          }
+        } catch (error) {
+          this.logger.error(`Failed to fetch message ${msgId.id}:`, {
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+      return messages;
+    } catch (error) {
+      throw this.mapGmailError(error);
+    }
+  }
+  async getMessage(messageId) {
+    this.ensureConnected();
+    try {
+      const response = await this.gmail?.users.messages.get({
+        userId: this.getUserId(),
+        id: messageId,
+        format: "raw"
+      });
+      if (!response || !response.data.raw) {
+        throw new MessageNotFoundError(messageId, "gmail");
+      }
+      const rawMessage = Buffer.from(response.data.raw, "base64").toString(
+        "utf-8"
+      );
+      const parsed = await simpleParser(rawMessage);
+      const labels = response.data.labelIds || [];
+      const extractAddresses = (addressObj) => {
+        if (!addressObj) return [];
+        const addressArray = Array.isArray(addressObj) ? addressObj : [addressObj];
+        const addresses = addressArray.flatMap(
+          (obj) => Array.isArray(obj.value) ? obj.value : [obj.value]
+        );
+        return addresses.map((addr) => ({
+          address: addr.address || "",
+          name: addr.name
+        }));
+      };
+      const fromAddresses = extractAddresses(parsed.from);
+      const toAddresses = extractAddresses(parsed.to);
+      const ccAddresses = extractAddresses(parsed.cc);
+      const bccAddresses = extractAddresses(parsed.bcc);
+      const replyToAddresses = extractAddresses(parsed.replyTo);
+      return {
+        id: response.data.id || void 0,
+        messageId: parsed.messageId || response.data.id || void 0,
+        threadId: response.data.threadId || void 0,
+        inReplyTo: parsed.inReplyTo,
+        references: parsed.references ? Array.isArray(parsed.references) ? parsed.references : [parsed.references] : void 0,
+        from: fromAddresses[0] || { address: "", name: void 0 },
+        to: toAddresses,
+        cc: ccAddresses.length > 0 ? ccAddresses : void 0,
+        bcc: bccAddresses.length > 0 ? bccAddresses : void 0,
+        replyTo: replyToAddresses[0],
+        subject: parsed.subject || "",
+        date: parsed.date,
+        text: parsed.text,
+        html: parsed.html ? parsed.html.toString() : void 0,
+        attachments: parsed.attachments?.map((att) => ({
+          filename: att.filename,
+          contentType: att.contentType,
+          size: att.size,
+          content: att.content,
+          contentId: att.contentId,
+          contentDisposition: att.contentDisposition
+        })),
+        labels,
+        headers: parsed.headers,
+        size: Number(response.data.sizeEstimate),
+        raw: rawMessage
+      };
+    } catch (error) {
+      if (error instanceof MessageNotFoundError) {
+        throw error;
+      }
+      throw this.mapGmailError(error);
+    }
+  }
+  // ========================================================================
+  // Label operations (Gmail uses labels instead of folders)
+  // ========================================================================
+  async listFolders() {
+    this.ensureConnected();
+    try {
+      const response = await this.gmail?.users.labels.list({
+        userId: this.getUserId()
+      });
+      if (!response) {
+        return [];
+      }
+      const labels = response.data.labels || [];
+      return labels.map((label) => ({
+        name: label.name || "",
+        path: label.id || "",
+        delimiter: "/",
+        specialUse: this.mapGmailLabelToSpecialUse(label.type),
+        messageCount: label.messagesTotal || void 0,
+        unreadCount: label.messagesUnread || void 0
+      }));
+    } catch (error) {
+      throw this.mapGmailError(error);
+    }
+  }
+  async selectFolder(name) {
+    this.ensureConnected();
+    try {
+      const labels = await this.listFolders();
+      const label = labels.find((l) => l.name === name || l.path === name);
+      if (!label) {
+        throw new FolderNotFoundError(name, "gmail");
+      }
+      return {
+        name: label.name,
+        exists: label.messageCount || 0,
+        recent: 0,
+        unseen: label.unreadCount || 0,
+        uidValidity: 0,
+        uidNext: 0,
+        flags: [],
+        permanentFlags: []
+      };
+    } catch (error) {
+      if (error instanceof FolderNotFoundError) {
+        throw error;
+      }
+      throw this.mapGmailError(error);
+    }
+  }
+  async createFolder(name) {
+    this.ensureConnected();
+    try {
+      const labels = await this.listFolders();
+      if (labels.some((l) => l.name === name)) {
+        throw new FolderExistsError(name, "gmail");
+      }
+      await this.gmail?.users.labels.create({
+        userId: this.getUserId(),
+        requestBody: {
+          name,
+          labelListVisibility: "labelShow",
+          messageListVisibility: "show"
+        }
+      });
+    } catch (error) {
+      if (error instanceof FolderExistsError) {
+        throw error;
+      }
+      throw this.mapGmailError(error);
+    }
+  }
+  async deleteFolder(name) {
+    this.ensureConnected();
+    try {
+      const labels = await this.listFolders();
+      const label = labels.find((l) => l.name === name);
+      if (!label) {
+        throw new FolderNotFoundError(name, "gmail");
+      }
+      if (label.specialUse) {
+        throw new EmailError(
+          `Cannot delete system label: ${name}`,
+          "INVALID_OPERATION",
+          "gmail"
+        );
+      }
+      await this.gmail?.users.labels.delete({
+        userId: this.getUserId(),
+        id: label.path
+      });
+    } catch (error) {
+      if (error instanceof FolderNotFoundError || error instanceof EmailError) {
+        throw error;
+      }
+      throw this.mapGmailError(error);
+    }
+  }
+  // ========================================================================
+  // Message operations
+  // ========================================================================
+  async markRead(messageId) {
+    this.ensureConnected();
+    const ids = this.normalizeMessageIds(messageId);
+    try {
+      for (const id of ids) {
+        await this.gmail?.users.messages.modify({
+          userId: this.getUserId(),
+          id,
+          requestBody: {
+            removeLabelIds: ["UNREAD"]
+          }
+        });
+      }
+    } catch (error) {
+      throw this.mapGmailError(error);
+    }
+  }
+  async markUnread(messageId) {
+    this.ensureConnected();
+    const ids = this.normalizeMessageIds(messageId);
+    try {
+      for (const id of ids) {
+        await this.gmail?.users.messages.modify({
+          userId: this.getUserId(),
+          id,
+          requestBody: {
+            addLabelIds: ["UNREAD"]
+          }
+        });
+      }
+    } catch (error) {
+      throw this.mapGmailError(error);
+    }
+  }
+  async move(messageId, folder) {
+    this.ensureConnected();
+    const ids = this.normalizeMessageIds(messageId);
+    try {
+      const labels = await this.listFolders();
+      const label = labels.find((l) => l.name === folder || l.path === folder);
+      if (!label) {
+        throw new FolderNotFoundError(folder, "gmail");
+      }
+      for (const id of ids) {
+        await this.gmail?.users.messages.modify({
+          userId: this.getUserId(),
+          id,
+          requestBody: {
+            addLabelIds: [label.path]
+          }
+        });
+      }
+    } catch (error) {
+      if (error instanceof FolderNotFoundError) {
+        throw error;
+      }
+      throw this.mapGmailError(error);
+    }
+  }
+  async copy(messageId, folder) {
+    await this.move(messageId, folder);
+  }
+  async delete(messageId) {
+    this.ensureConnected();
+    const ids = this.normalizeMessageIds(messageId);
+    try {
+      for (const id of ids) {
+        await this.gmail?.users.messages.trash({
+          userId: this.getUserId(),
+          id
+        });
+      }
+    } catch (error) {
+      throw this.mapGmailError(error);
+    }
+  }
+  // ========================================================================
+  // Search
+  // ========================================================================
+  async search(criteria) {
+    this.ensureConnected();
+    try {
+      if (criteria.q) {
+        return await this.fetch({ q: criteria.q });
+      }
+      const queryParts = [];
+      if (criteria.from) queryParts.push(`from:${criteria.from}`);
+      if (criteria.to) queryParts.push(`to:${criteria.to}`);
+      if (criteria.subject) queryParts.push(`subject:${criteria.subject}`);
+      if (criteria.body) queryParts.push(criteria.body);
+      if (criteria.since) {
+        queryParts.push(`after:${this.formatGmailDate(criteria.since)}`);
+      }
+      if (criteria.before) {
+        queryParts.push(`before:${this.formatGmailDate(criteria.before)}`);
+      }
+      if (criteria.unread === true) queryParts.push("is:unread");
+      if (criteria.unread === false) queryParts.push("is:read");
+      if (criteria.flagged) queryParts.push("is:starred");
+      if (criteria.larger) queryParts.push(`larger:${criteria.larger}`);
+      if (criteria.smaller) queryParts.push(`smaller:${criteria.smaller}`);
+      const query = queryParts.join(" ");
+      return await this.fetch({ q: query });
+    } catch (error) {
+      throw this.mapGmailError(error);
+    }
+  }
+  // ========================================================================
+  // Adapter info
+  // ========================================================================
+  async getCapabilities() {
+    return {
+      send: true,
+      receive: true,
+      folders: true,
+      search: true,
+      markRead: true,
+      move: true,
+      delete: true,
+      threads: true,
+      oauth: true
+    };
+  }
+  getAdapter() {
+    return "gmail";
+  }
+  // ========================================================================
+  // Private helper methods
+  // ========================================================================
+  ensureConnected() {
+    if (!this.connected || !this.gmail) {
+      throw new ConnectionError(
+        "Not connected to Gmail. Call connect() first.",
+        "gmail"
+      );
+    }
+  }
+  getUserId() {
+    return this.options.userId || "me";
+  }
+  buildRFC2822Message(message, options) {
+    const lines = [];
+    const hasAttachments = message.attachments && message.attachments.length > 0;
+    lines.push(`From: ${this.formatEmailAddress(message.from)}`);
+    lines.push(
+      `To: ${message.to.map((a) => this.formatEmailAddress(a)).join(", ")}`
+    );
+    if (message.cc && message.cc.length > 0) {
+      lines.push(
+        `Cc: ${message.cc.map((a) => this.formatEmailAddress(a)).join(", ")}`
+      );
+    }
+    if (message.replyTo) {
+      lines.push(`Reply-To: ${this.formatEmailAddress(message.replyTo)}`);
+    }
+    lines.push(`Subject: ${message.subject}`);
+    lines.push(
+      `Date: ${options?.date?.toUTCString() || (/* @__PURE__ */ new Date()).toUTCString()}`
+    );
+    if (options?.messageId) {
+      lines.push(`Message-ID: <${options.messageId}>`);
+    }
+    lines.push("MIME-Version: 1.0");
+    if (hasAttachments) {
+      lines.push('Content-Type: multipart/mixed; boundary="mixed-boundary"');
+      lines.push("");
+      lines.push("--mixed-boundary");
+      if (message.html) {
+        lines.push(
+          'Content-Type: multipart/alternative; boundary="alt-boundary"'
+        );
+        lines.push("");
+        lines.push("--alt-boundary");
+        lines.push('Content-Type: text/plain; charset="UTF-8"');
+        lines.push("Content-Transfer-Encoding: 7bit");
+        lines.push("");
+        lines.push(message.text || "");
+        lines.push("");
+        lines.push("--alt-boundary");
+        lines.push('Content-Type: text/html; charset="UTF-8"');
+        lines.push("Content-Transfer-Encoding: 7bit");
+        lines.push("");
+        lines.push(message.html);
+        lines.push("");
+        lines.push("--alt-boundary--");
+      } else {
+        lines.push('Content-Type: text/plain; charset="UTF-8"');
+        lines.push("Content-Transfer-Encoding: 7bit");
+        lines.push("");
+        lines.push(message.text || "");
+      }
+      if (message.attachments) {
+        for (const attachment of message.attachments) {
+          lines.push("");
+          lines.push("--mixed-boundary");
+          lines.push(
+            `Content-Type: ${attachment.contentType}; name="${attachment.filename}"`
+          );
+          lines.push("Content-Transfer-Encoding: base64");
+          lines.push(
+            `Content-Disposition: ${attachment.contentDisposition || "attachment"}; filename="${attachment.filename}"`
+          );
+          if (attachment.contentId) {
+            lines.push(`Content-ID: <${attachment.contentId}>`);
+          }
+          lines.push("");
+          const content = attachment.content || Buffer.from("");
+          const base64Content = content.toString("base64");
+          const base64Lines = base64Content.match(/.{1,76}/g) || [];
+          lines.push(...base64Lines);
+        }
+      }
+      lines.push("");
+      lines.push("--mixed-boundary--");
+    } else {
+      if (message.html) {
+        lines.push(
+          'Content-Type: multipart/alternative; boundary="alt-boundary"'
+        );
+        lines.push("");
+        lines.push("--alt-boundary");
+        lines.push('Content-Type: text/plain; charset="UTF-8"');
+        lines.push("Content-Transfer-Encoding: 7bit");
+        lines.push("");
+        lines.push(message.text || "");
+        lines.push("");
+        lines.push("--alt-boundary");
+        lines.push('Content-Type: text/html; charset="UTF-8"');
+        lines.push("Content-Transfer-Encoding: 7bit");
+        lines.push("");
+        lines.push(message.html);
+        lines.push("");
+        lines.push("--alt-boundary--");
+      } else {
+        lines.push('Content-Type: text/plain; charset="UTF-8"');
+        lines.push("Content-Transfer-Encoding: 7bit");
+        lines.push("");
+        lines.push(message.text || "");
+      }
+    }
+    return lines.join("\r\n");
+  }
+  formatEmailAddress(addr) {
+    if (addr.name) {
+      return `${addr.name} <${addr.address}>`;
+    }
+    return addr.address;
+  }
+  buildGmailQuery(options) {
+    const queryParts = [];
+    if (options?.q) {
+      return options.q;
+    }
+    if (options?.since) {
+      queryParts.push(`after:${this.formatGmailDate(options.since)}`);
+    }
+    if (options?.before) {
+      queryParts.push(`before:${this.formatGmailDate(options.before)}`);
+    }
+    if (options?.unreadOnly) {
+      queryParts.push("is:unread");
+    }
+    return queryParts.join(" ");
+  }
+  formatGmailDate(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    return `${year}/${month}/${day}`;
+  }
+  mapGmailLabelToSpecialUse(type) {
+    switch (type) {
+      case "system":
+        return "\\Inbox";
+      default:
+        return void 0;
+    }
+  }
+  mapGmailError(error) {
+    if (error instanceof EmailError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      const message = error.message.toLowerCase();
+      const errorObj = error;
+      if (message.includes("timeout") || errorObj.code === "ETIMEDOUT" || errorObj.code === "ESOCKETTIMEDOUT") {
+        return new TimeoutError(error.message, "gmail", error);
+      }
+      if (message.includes("network") || message.includes("connect") || errorObj.code === "ECONNREFUSED" || errorObj.code === "ENOTFOUND" || errorObj.code === "ECONNRESET") {
+        return new ConnectionError(error.message, "gmail", error);
+      }
+      if (message.includes("auth") || message.includes("invalid_grant") || message.includes("unauthorized") || errorObj.code === 401) {
+        return new AuthenticationError(error.message, "gmail", error);
+      }
+      if (message.includes("recipient") || message.includes("invalid email")) {
+        return new SendError(error.message, [], [], "gmail", error);
+      }
+      return new EmailError(error.message, "GMAIL_ERROR", "gmail", error);
+    }
+    return new EmailError(String(error), "GMAIL_ERROR", "gmail");
+  }
+}
+const gmail = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  GmailAdapter
+}, Symbol.toStringTag, { value: "Module" }));
+class IMAPAdapter extends BaseEmailClient {
+  client = null;
+  options;
+  currentFolder = null;
+  constructor(options) {
+    super({
+      type: "imap",
+      debug: options.debug
+    });
+    this.options = options;
+  }
+  /**
+   * Create ImapFlow client
+   */
+  createClient() {
+    const config = {
+      host: this.options.host,
+      port: this.options.port,
+      secure: this.options.secure ?? true,
+      auth: this.options.auth,
+      tls: this.options.tls,
+      logger: this.options.debug ? {
+        debug: (msg) => this.debug(msg),
+        info: (msg) => this.debug(msg),
+        warn: (msg) => this.debug(`WARN: ${msg}`),
+        error: (msg) => this.debug(`ERROR: ${msg}`)
+      } : false
+    };
+    return new ImapFlow(config);
+  }
+  getAdapter() {
+    return "imap";
+  }
+  /**
+   * Helper to convert search results to array
+   */
+  searchResultToArray(result) {
+    if (!result || !Array.isArray(result)) {
+      return [];
+    }
+    return result;
+  }
+  /**
+   * Connect to IMAP server
+   */
+  async connect() {
+    try {
+      this.debug("Connecting to IMAP server", { host: this.options.host });
+      this.client = this.createClient();
+      await this.client.connect();
+      this.connected = true;
+      this.debug("IMAP connection established");
+    } catch (error) {
+      this.connected = false;
+      throw this.mapIMAPError(error);
+    }
+  }
+  /**
+   * Disconnect from IMAP server
+   */
+  async disconnect() {
+    if (this.client) {
+      await this.client.logout();
+      this.client = null;
+      this.connected = false;
+      this.currentFolder = null;
+      this.debug("IMAP connection closed");
+    }
+  }
+  /**
+   * Fetch messages with filters
+   */
+  async fetch(options) {
+    this.ensureConnected();
+    const folder = options?.folder || "INBOX";
+    await this.selectFolder(folder);
+    try {
+      const searchQuery = this.buildSearchQuery(options);
+      this.debug("Fetching messages", { folder, query: searchQuery });
+      const searchResult = await this.client.search(searchQuery, {
+        uid: true
+      });
+      const uids = this.searchResultToArray(searchResult);
+      let targetUids = uids;
+      if (options?.offset || options?.limit) {
+        const start = options.offset || 0;
+        const end = options.limit ? start + options.limit : void 0;
+        targetUids = uids.slice(start, end);
+      }
+      if (targetUids.length === 0) {
+        return [];
+      }
+      const messages = [];
+      for await (const msg of this.client.fetch(targetUids, {
+        source: true,
+        flags: true,
+        uid: true,
+        envelope: true,
+        bodyStructure: true
+      })) {
+        try {
+          if (!msg.source) {
+            this.debug("Message has no source", { uid: msg.uid });
+            continue;
+          }
+          const parsed = await simpleParser(msg.source);
+          const email = this.parseMessage(parsed, msg);
+          messages.push(email);
+          if (options?.markSeen) {
+            await this.client.messageFlagsAdd(msg.uid, ["\\Seen"], {
+              uid: true
+            });
+          }
+        } catch (parseError) {
+          this.debug("Failed to parse message", { uid: msg.uid, parseError });
+        }
+      }
+      return messages;
+    } catch (error) {
+      throw this.mapIMAPError(error);
+    }
+  }
+  /**
+   * Get a specific message by ID
+   */
+  async getMessage(messageId) {
+    this.ensureConnected();
+    try {
+      const searchResult = await this.client.search(
+        { header: ["message-id", messageId] },
+        { uid: true }
+      );
+      const uids = this.searchResultToArray(searchResult);
+      if (uids.length === 0) {
+        throw new MessageNotFoundError(messageId, "imap");
+      }
+      const messages = [];
+      for await (const msg of this.client.fetch(uids[0], {
+        source: true,
+        flags: true,
+        uid: true
+      })) {
+        if (!msg.source) {
+          continue;
+        }
+        const parsed = await simpleParser(msg.source);
+        messages.push(this.parseMessage(parsed, msg));
+      }
+      if (messages.length === 0) {
+        throw new MessageNotFoundError(messageId, "imap");
+      }
+      return messages[0];
+    } catch (error) {
+      if (error instanceof EmailError) {
+        throw error;
+      }
+      throw this.mapIMAPError(error);
+    }
+  }
+  /**
+   * List all folders
+   */
+  async listFolders() {
+    this.ensureConnected();
+    try {
+      const list = await this.client?.list();
+      if (!list) {
+        return [];
+      }
+      return list.map((folder) => ({
+        name: folder.name,
+        path: folder.path,
+        delimiter: folder.delimiter,
+        specialUse: folder.specialUse,
+        subscribed: folder.subscribed
+      }));
+    } catch (error) {
+      throw this.mapIMAPError(error);
+    }
+  }
+  /**
+   * Select a folder
+   */
+  async selectFolder(name) {
+    this.ensureConnected();
+    try {
+      const mailbox = await this.client?.mailboxOpen(name);
+      this.currentFolder = name;
+      if (!mailbox) {
+        throw new FolderNotFoundError(name, "imap");
+      }
+      return {
+        name,
+        exists: Number(mailbox.exists),
+        recent: 0,
+        // ImapFlow doesn't provide this
+        unseen: 0,
+        // Would need separate STATUS command
+        uidValidity: Number(mailbox.uidValidity),
+        uidNext: Number(mailbox.uidNext),
+        flags: Array.from(mailbox.flags || []),
+        permanentFlags: Array.from(mailbox.permanentFlags || [])
+      };
+    } catch (error) {
+      if (error instanceof Error && error.message.toLowerCase().includes("does not exist")) {
+        throw new FolderNotFoundError(name, "imap");
+      }
+      throw this.mapIMAPError(error);
+    }
+  }
+  /**
+   * Create a new folder
+   */
+  async createFolder(name) {
+    this.ensureConnected();
+    try {
+      await this.client?.mailboxCreate(name);
+      this.debug("Folder created", { name });
+    } catch (error) {
+      if (error instanceof Error && error.message.toLowerCase().includes("already exists")) {
+        throw new FolderExistsError(name, "imap");
+      }
+      throw this.mapIMAPError(error);
+    }
+  }
+  /**
+   * Delete a folder
+   */
+  async deleteFolder(name) {
+    this.ensureConnected();
+    try {
+      await this.client?.mailboxDelete(name);
+      this.debug("Folder deleted", { name });
+    } catch (error) {
+      if (error instanceof Error && error.message.toLowerCase().includes("does not exist")) {
+        throw new FolderNotFoundError(name, "imap");
+      }
+      throw this.mapIMAPError(error);
+    }
+  }
+  /**
+   * Mark message(s) as read
+   */
+  async markRead(messageId) {
+    this.ensureConnected();
+    const ids = Array.isArray(messageId) ? messageId : [messageId];
+    try {
+      for (const id of ids) {
+        const searchResult = await this.client?.search(
+          { header: ["message-id", id] },
+          { uid: true }
+        );
+        const uids = this.searchResultToArray(searchResult);
+        if (uids.length > 0) {
+          await this.client?.messageFlagsAdd(uids[0], ["\\Seen"], {
+            uid: true
+          });
+        }
+      }
+    } catch (error) {
+      throw this.mapIMAPError(error);
+    }
+  }
+  /**
+   * Mark message(s) as unread
+   */
+  async markUnread(messageId) {
+    this.ensureConnected();
+    const ids = Array.isArray(messageId) ? messageId : [messageId];
+    try {
+      for (const id of ids) {
+        const searchResult = await this.client?.search(
+          { header: ["message-id", id] },
+          { uid: true }
+        );
+        const uids = this.searchResultToArray(searchResult);
+        if (uids.length > 0) {
+          await this.client?.messageFlagsRemove(uids[0], ["\\Seen"], {
+            uid: true
+          });
+        }
+      }
+    } catch (error) {
+      throw this.mapIMAPError(error);
+    }
+  }
+  /**
+   * Move message(s) to another folder
+   */
+  async move(messageId, folder) {
+    this.ensureConnected();
+    const ids = Array.isArray(messageId) ? messageId : [messageId];
+    try {
+      for (const id of ids) {
+        const searchResult = await this.client?.search(
+          { header: ["message-id", id] },
+          { uid: true }
+        );
+        const uids = this.searchResultToArray(searchResult);
+        if (uids.length > 0) {
+          await this.client?.messageMove(uids[0], folder, { uid: true });
+        }
+      }
+    } catch (error) {
+      throw this.mapIMAPError(error);
+    }
+  }
+  /**
+   * Copy message(s) to another folder
+   */
+  async copy(messageId, folder) {
+    this.ensureConnected();
+    const ids = Array.isArray(messageId) ? messageId : [messageId];
+    try {
+      for (const id of ids) {
+        const searchResult = await this.client?.search(
+          { header: ["message-id", id] },
+          { uid: true }
+        );
+        const uids = this.searchResultToArray(searchResult);
+        if (uids.length > 0) {
+          await this.client?.messageCopy(uids[0], folder, { uid: true });
+        }
+      }
+    } catch (error) {
+      throw this.mapIMAPError(error);
+    }
+  }
+  /**
+   * Delete message(s)
+   */
+  async delete(messageId) {
+    this.ensureConnected();
+    const ids = Array.isArray(messageId) ? messageId : [messageId];
+    try {
+      for (const id of ids) {
+        const searchResult = await this.client?.search(
+          { header: ["message-id", id] },
+          { uid: true }
+        );
+        const uids = this.searchResultToArray(searchResult);
+        if (uids.length > 0) {
+          await this.client?.messageFlagsAdd(uids[0], ["\\Deleted"], {
+            uid: true
+          });
+        }
+      }
+    } catch (error) {
+      throw this.mapIMAPError(error);
+    }
+  }
+  /**
+   * Search messages
+   */
+  async search(criteria) {
+    this.ensureConnected();
+    try {
+      const query = this.buildSearchCriteria(criteria);
+      const searchResult = await this.client.search(query, { uid: true });
+      const uids = this.searchResultToArray(searchResult);
+      if (uids.length === 0) {
+        return [];
+      }
+      const messages = [];
+      for await (const msg of this.client.fetch(uids, {
+        source: true,
+        flags: true,
+        uid: true
+      })) {
+        if (!msg.source) {
+          continue;
+        }
+        const parsed = await simpleParser(msg.source);
+        messages.push(this.parseMessage(parsed, msg));
+      }
+      return messages;
+    } catch (error) {
+      throw this.mapIMAPError(error);
+    }
+  }
+  /**
+   * Get adapter capabilities
+   */
+  async getCapabilities() {
+    return {
+      send: false,
+      // IMAP is receive-only
+      receive: true,
+      folders: true,
+      search: true,
+      markRead: true,
+      move: true,
+      delete: true,
+      threads: false,
+      // Thread support not implemented yet
+      oauth: this.isOAuth2()
+    };
+  }
+  /**
+   * Check if using OAuth2 authentication
+   */
+  isOAuth2() {
+    return this.options.auth !== void 0 && "type" in this.options.auth && this.options.auth.type === "OAuth2";
+  }
+  // ========================================================================
+  // Unsupported operations (IMAP is receive-only)
+  // ========================================================================
+  async send(_message, _options) {
+    throw new EmailError(
+      "IMAP does not support sending messages. Use SMTP adapter.",
+      "UNSUPPORTED_OPERATION",
+      "imap"
+    );
+  }
+  // ========================================================================
+  // Helper methods
+  // ========================================================================
+  /**
+   * Ensure client is connected
+   */
+  ensureConnected() {
+    if (!this.client || !this.connected) {
+      throw new ConnectionError(
+        "Not connected to IMAP server. Call connect() first.",
+        "imap"
+      );
+    }
+  }
+  /**
+   * Build IMAP search query from FetchOptions
+   */
+  buildSearchQuery(options) {
+    const query = {};
+    if (options?.unreadOnly) {
+      query.unseen = true;
+    }
+    if (options?.since) {
+      query.since = options.since;
+    }
+    if (options?.before) {
+      query.before = options.before;
+    }
+    if (Object.keys(query).length === 0) {
+      query.all = true;
+    }
+    return query;
+  }
+  /**
+   * Build IMAP search criteria from SearchCriteria
+   */
+  buildSearchCriteria(criteria) {
+    const query = {};
+    if (criteria.from) {
+      query.from = criteria.from;
+    }
+    if (criteria.to) {
+      query.to = criteria.to;
+    }
+    if (criteria.subject) {
+      query.subject = criteria.subject;
+    }
+    if (criteria.body) {
+      query.body = criteria.body;
+    }
+    if (criteria.since) {
+      query.since = criteria.since;
+    }
+    if (criteria.before) {
+      query.before = criteria.before;
+    }
+    if (criteria.unread) {
+      query.unseen = true;
+    }
+    if (criteria.flagged) {
+      query.flagged = true;
+    }
+    if (criteria.answered) {
+      query.answered = true;
+    }
+    if (criteria.draft) {
+      query.draft = true;
+    }
+    if (criteria.deleted) {
+      query.deleted = true;
+    }
+    if (criteria.larger) {
+      query.larger = criteria.larger;
+    }
+    if (criteria.smaller) {
+      query.smaller = criteria.smaller;
+    }
+    if (criteria.header) {
+      query.header = Object.entries(criteria.header).map(([key, value]) => [
+        key,
+        value
+      ]);
+    }
+    if (Object.keys(query).length === 0) {
+      query.all = true;
+    }
+    return query;
+  }
+  /**
+   * Parse mailparser output to EmailMessage
+   */
+  parseMessage(parsed, msg) {
+    const extractAddresses = (addressObj) => {
+      if (!addressObj) return [];
+      const addressArray = Array.isArray(addressObj) ? addressObj : [addressObj];
+      const addresses = addressArray.flatMap(
+        (obj) => Array.isArray(obj.value) ? obj.value : [obj.value]
+      );
+      return addresses.map((addr) => ({
+        address: addr.address || "",
+        name: addr.name
+      }));
+    };
+    const fromAddresses = extractAddresses(parsed.from);
+    const toAddresses = extractAddresses(parsed.to);
+    const ccAddresses = extractAddresses(parsed.cc);
+    const bccAddresses = extractAddresses(parsed.bcc);
+    const replyToAddresses = extractAddresses(parsed.replyTo);
+    return {
+      id: String(msg.uid),
+      messageId: parsed.messageId || void 0,
+      from: fromAddresses[0] || { address: "", name: void 0 },
+      to: toAddresses,
+      cc: ccAddresses.length > 0 ? ccAddresses : void 0,
+      bcc: bccAddresses.length > 0 ? bccAddresses : void 0,
+      replyTo: replyToAddresses[0],
+      subject: parsed.subject || "",
+      date: parsed.date,
+      text: parsed.text,
+      html: parsed.html ? String(parsed.html) : void 0,
+      attachments: parsed.attachments?.map((att) => ({
+        filename: att.filename,
+        contentType: att.contentType,
+        size: att.size,
+        content: att.content,
+        contentId: att.contentId,
+        contentDisposition: att.contentDisposition
+      })),
+      flags: msg.flags ? Array.from(msg.flags) : void 0,
+      inReplyTo: parsed.inReplyTo,
+      references: Array.isArray(parsed.references) ? parsed.references : parsed.references ? [parsed.references] : void 0,
+      headers: parsed.headers ? Object.fromEntries(
+        Array.from(parsed.headers.entries()).map(([key, value]) => [
+          key,
+          Array.isArray(value) ? value : String(value)
+        ])
+      ) : void 0
+    };
+  }
+  /**
+   * Map ImapFlow errors to standard error types
+   */
+  mapIMAPError(error) {
+    if (error instanceof EmailError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      const message = error.message.toLowerCase();
+      if (message.includes("authentication") || message.includes("auth") || message.includes("login") || message.includes("invalid credentials")) {
+        return new AuthenticationError(error.message, "imap", error);
+      }
+      if (message.includes("timeout") || message.includes("etimedout")) {
+        return new TimeoutError(error.message, "imap", error);
+      }
+      if (message.includes("econnrefused") || message.includes("enotfound") || message.includes("connection") || message.includes("ehostunreach") || message.includes("network")) {
+        return new ConnectionError(error.message, "imap", error);
+      }
+      return new EmailError(error.message, "IMAP_ERROR", "imap", error);
+    }
+    return new EmailError(String(error), "UNKNOWN_ERROR", "imap");
+  }
+}
+const imap = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  IMAPAdapter
+}, Symbol.toStringTag, { value: "Module" }));
+class POP3Adapter extends BaseEmailClient {
+  client = null;
+  options;
+  messageCache = /* @__PURE__ */ new Map();
+  // msgNum -> UID
+  constructor(options) {
+    super({
+      type: "pop3",
+      debug: options.debug
+    });
+    this.options = options;
+  }
+  // ========================================================================
+  // Connection management
+  // ========================================================================
+  async connect() {
+    try {
+      this.client = new Pop3Command({
+        user: this.options.auth.user,
+        password: this.options.auth.pass,
+        host: this.options.host,
+        port: this.options.port,
+        tls: this.options.secure ?? this.options.port === 995,
+        timeout: this.options.connectionTimeout,
+        tlsOptions: this.options.tls
+      });
+      await this.client.connect();
+      this.connected = true;
+      this.debug("Connected to POP3 server");
+    } catch (error) {
+      throw this.mapPOP3Error(error);
+    }
+  }
+  async disconnect() {
+    if (!this.client) {
+      return;
+    }
+    try {
+      await this.client.QUIT();
+      this.client = null;
+      this.connected = false;
+      this.messageCache.clear();
+      this.debug("Disconnected from POP3 server");
+    } catch (error) {
+      this.client = null;
+      this.connected = false;
+      this.messageCache.clear();
+      throw this.mapPOP3Error(error);
+    }
+  }
+  // ========================================================================
+  // Message operations
+  // ========================================================================
+  async fetch(options) {
+    this.ensureConnected();
+    try {
+      const uidlResponse = await this.client?.UIDL();
+      if (!uidlResponse || !uidlResponse[0]) {
+        return [];
+      }
+      const uidList = this.parseUidlResponse(
+        Array.isArray(uidlResponse[0]) ? uidlResponse[0].join("\n") : uidlResponse[0]
+      );
+      if (uidList.length === 0) {
+        return [];
+      }
+      this.messageCache.clear();
+      for (const { msgNum, uid } of uidList) {
+        this.messageCache.set(msgNum, uid);
+      }
+      let messageNums = uidList.map((item) => item.msgNum);
+      if (options?.offset) {
+        messageNums = messageNums.slice(options.offset);
+      }
+      if (options?.limit) {
+        messageNums = messageNums.slice(0, options.limit);
+      }
+      const messages = [];
+      for (const msgNum of messageNums) {
+        try {
+          const message = await this.fetchMessage(msgNum);
+          if (this.shouldIncludeMessage(message, options)) {
+            messages.push(message);
+            if (!this.options.leaveOnServer) {
+              await this.deleteMessageByNum(msgNum);
+            }
+          }
+        } catch (error) {
+          this.logger.error(`Failed to fetch message ${msgNum}:`, {
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+      return messages;
+    } catch (error) {
+      throw this.mapPOP3Error(error);
+    }
+  }
+  async getMessage(messageId) {
+    this.ensureConnected();
+    try {
+      let msgNum = null;
+      for (const [num, uid] of this.messageCache.entries()) {
+        if (uid === messageId) {
+          msgNum = num;
+          break;
+        }
+      }
+      if (!msgNum) {
+        const uidlResponse = await this.client?.UIDL();
+        if (!uidlResponse || !uidlResponse[0]) {
+          throw new MessageNotFoundError(messageId, "pop3");
+        }
+        const uidList = this.parseUidlResponse(
+          Array.isArray(uidlResponse[0]) ? uidlResponse[0].join("\n") : uidlResponse[0]
+        );
+        this.messageCache.clear();
+        for (const { msgNum: num, uid } of uidList) {
+          this.messageCache.set(num, uid);
+          if (uid === messageId) {
+            msgNum = num;
+          }
+        }
+      }
+      if (!msgNum) {
+        throw new MessageNotFoundError(messageId, "pop3");
+      }
+      return await this.fetchMessage(msgNum);
+    } catch (error) {
+      if (error instanceof MessageNotFoundError) {
+        throw error;
+      }
+      throw this.mapPOP3Error(error);
+    }
+  }
+  async delete(messageId) {
+    this.ensureConnected();
+    const ids = this.normalizeMessageIds(messageId);
+    for (const id of ids) {
+      try {
+        let msgNum = null;
+        for (const [num, uid] of this.messageCache.entries()) {
+          if (uid === id) {
+            msgNum = num;
+            break;
+          }
+        }
+        if (!msgNum) {
+          const uidlResponse = await this.client?.UIDL();
+          if (!uidlResponse || !uidlResponse[0]) {
+            throw new MessageNotFoundError(id, "pop3");
+          }
+          const uidList = this.parseUidlResponse(
+            Array.isArray(uidlResponse[0]) ? uidlResponse[0].join("\n") : uidlResponse[0]
+          );
+          for (const { msgNum: num, uid } of uidList) {
+            if (uid === id) {
+              msgNum = num;
+              break;
+            }
+          }
+        }
+        if (!msgNum) {
+          throw new MessageNotFoundError(id, "pop3");
+        }
+        await this.deleteMessageByNum(msgNum);
+      } catch (error) {
+        throw this.mapPOP3Error(error);
+      }
+    }
+  }
+  // ========================================================================
+  // Unsupported operations (POP3 limitations)
+  // ========================================================================
+  async send(_message, _options) {
+    throw new EmailError(
+      "POP3 does not support sending email. Use SMTP instead.",
+      "UNSUPPORTED_OPERATION",
+      "pop3"
+    );
+  }
+  async listFolders() {
+    throw new EmailError(
+      "POP3 does not support folders",
+      "UNSUPPORTED_OPERATION",
+      "pop3"
+    );
+  }
+  async selectFolder(_name) {
+    throw new EmailError(
+      "POP3 does not support folders",
+      "UNSUPPORTED_OPERATION",
+      "pop3"
+    );
+  }
+  async createFolder(_name) {
+    throw new EmailError(
+      "POP3 does not support folders",
+      "UNSUPPORTED_OPERATION",
+      "pop3"
+    );
+  }
+  async deleteFolder(_name) {
+    throw new EmailError(
+      "POP3 does not support folders",
+      "UNSUPPORTED_OPERATION",
+      "pop3"
+    );
+  }
+  async markRead(_messageId) {
+    throw new EmailError(
+      "POP3 does not support marking messages as read",
+      "UNSUPPORTED_OPERATION",
+      "pop3"
+    );
+  }
+  async markUnread(_messageId) {
+    throw new EmailError(
+      "POP3 does not support marking messages as unread",
+      "UNSUPPORTED_OPERATION",
+      "pop3"
+    );
+  }
+  async move(_messageId, _folder) {
+    throw new EmailError(
+      "POP3 does not support moving messages",
+      "UNSUPPORTED_OPERATION",
+      "pop3"
+    );
+  }
+  async copy(_messageId, _folder) {
+    throw new EmailError(
+      "POP3 does not support copying messages",
+      "UNSUPPORTED_OPERATION",
+      "pop3"
+    );
+  }
+  async search(_criteria) {
+    throw new EmailError(
+      "POP3 does not support server-side search. Use fetch() with filters instead.",
+      "UNSUPPORTED_OPERATION",
+      "pop3"
+    );
+  }
+  // ========================================================================
+  // Adapter info
+  // ========================================================================
+  async getCapabilities() {
+    return {
+      send: false,
+      receive: true,
+      folders: false,
+      search: false,
+      markRead: false,
+      move: false,
+      delete: true,
+      threads: false,
+      oauth: false
+    };
+  }
+  getAdapter() {
+    return "pop3";
+  }
+  // ========================================================================
+  // Private helper methods
+  // ========================================================================
+  ensureConnected() {
+    if (!this.connected || !this.client) {
+      throw new ConnectionError(
+        "Not connected to POP3 server. Call connect() first.",
+        "pop3"
+      );
+    }
+  }
+  async fetchMessage(msgNum) {
+    try {
+      const response = await this.client?.RETR(Number(msgNum));
+      if (!response || !response[0]) {
+        throw new Error(`Failed to retrieve message ${msgNum}`);
+      }
+      const messageData = response[0];
+      const parsed = await simpleParser(messageData);
+      const uid = this.messageCache.get(msgNum);
+      const extractAddresses = (addressObj) => {
+        if (!addressObj) return [];
+        const addressArray = Array.isArray(addressObj) ? addressObj : [addressObj];
+        const addresses = addressArray.flatMap(
+          (obj) => Array.isArray(obj.value) ? obj.value : [obj.value]
+        );
+        return addresses.map((addr) => ({
+          address: addr.address || "",
+          name: addr.name
+        }));
+      };
+      const fromAddresses = extractAddresses(parsed.from);
+      const toAddresses = extractAddresses(parsed.to);
+      const ccAddresses = extractAddresses(parsed.cc);
+      const bccAddresses = extractAddresses(parsed.bcc);
+      const replyToAddresses = extractAddresses(parsed.replyTo);
+      return {
+        id: uid || msgNum,
+        messageId: parsed.messageId || uid || msgNum,
+        from: fromAddresses[0] || { address: "", name: void 0 },
+        to: toAddresses,
+        cc: ccAddresses.length > 0 ? ccAddresses : void 0,
+        bcc: bccAddresses.length > 0 ? bccAddresses : void 0,
+        replyTo: replyToAddresses[0],
+        subject: parsed.subject || "",
+        date: parsed.date,
+        text: parsed.text,
+        html: parsed.html ? parsed.html.toString() : void 0,
+        attachments: parsed.attachments?.map((att) => ({
+          filename: att.filename,
+          contentType: att.contentType,
+          size: att.size,
+          content: att.content,
+          contentId: att.contentId,
+          contentDisposition: att.contentDisposition
+        })),
+        headers: parsed.headers,
+        size: messageData.length,
+        raw: messageData
+      };
+    } catch (error) {
+      throw this.mapPOP3Error(error);
+    }
+  }
+  async deleteMessageByNum(msgNum) {
+    try {
+      await this.client?.command(`DELE ${msgNum}`);
+      this.messageCache.delete(msgNum);
+      this.debug(`Deleted message ${msgNum}`);
+    } catch (error) {
+      throw this.mapPOP3Error(error);
+    }
+  }
+  parseUidlResponse(response) {
+    const lines = response.split("\n");
+    const result = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed === "." || trimmed.startsWith("+OK")) {
+        continue;
+      }
+      const parts = trimmed.split(/\s+/);
+      if (parts.length >= 2) {
+        result.push({
+          msgNum: parts[0],
+          uid: parts[1]
+        });
+      }
+    }
+    return result;
+  }
+  shouldIncludeMessage(message, options) {
+    if (options?.since && message.date) {
+      if (message.date < options.since) {
+        return false;
+      }
+    }
+    if (options?.before && message.date) {
+      if (message.date >= options.before) {
+        return false;
+      }
+    }
+    return true;
+  }
+  mapPOP3Error(error) {
+    if (error instanceof EmailError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      const message = error.message.toLowerCase();
+      const errorObj = error;
+      if (message.includes("timeout") || errorObj.eventName === "timeout" || errorObj.code === "ETIMEDOUT") {
+        return new TimeoutError(error.message, "pop3", error);
+      }
+      if (message.includes("connect") || message.includes("econnrefused") || message.includes("enotfound") || message.includes("ehostunreach") || errorObj.eventName === "error" || errorObj.eventName === "close" || errorObj.code === "ECONNREFUSED" || errorObj.code === "ENOTFOUND") {
+        return new ConnectionError(error.message, "pop3", error);
+      }
+      if (message.includes("auth") || message.includes("login") || message.includes("password") || message.includes("user") || message.includes("-err")) {
+        return new AuthenticationError(error.message, "pop3", error);
+      }
+      return new EmailError(error.message, "POP3_ERROR", "pop3", error);
+    }
+    return new EmailError(String(error), "POP3_ERROR", "pop3");
+  }
+}
+const pop3 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  POP3Adapter
+}, Symbol.toStringTag, { value: "Module" }));
+class SMTPAdapter extends BaseEmailClient {
+  transporter;
+  options;
+  constructor(options) {
+    super({
+      type: "smtp",
+      debug: options.debug
+    });
+    this.options = options;
+    this.transporter = this.createTransporter();
+  }
+  /**
+   * Create Nodemailer transporter with configuration
+   */
+  createTransporter() {
+    const config = {
+      host: this.options.host,
+      port: this.options.port,
+      secure: this.options.secure ?? false,
+      auth: this.options.auth,
+      tls: this.options.tls,
+      connectionTimeout: this.options.connectionTimeout,
+      greetingTimeout: this.options.greetingTimeout,
+      socketTimeout: this.options.socketTimeout,
+      pool: this.options.pool,
+      maxConnections: this.options.maxConnections,
+      maxMessages: this.options.maxMessages,
+      debug: this.options.debug
+    };
+    return nodemailer.createTransport(config);
+  }
+  getAdapter() {
+    return "smtp";
+  }
+  /**
+   * Send an email message
+   */
+  async send(message, options) {
+    this.validateMessage(message);
+    try {
+      const mailOptions = {
+        from: this.formatEmailAddress(message.from),
+        to: message.to.map((addr) => this.formatEmailAddress(addr)),
+        cc: message.cc?.map((addr) => this.formatEmailAddress(addr)),
+        bcc: message.bcc?.map((addr) => this.formatEmailAddress(addr)),
+        subject: message.subject,
+        text: message.text,
+        html: message.html,
+        replyTo: message.replyTo ? this.formatEmailAddress(message.replyTo) : void 0,
+        inReplyTo: message.inReplyTo,
+        references: message.references,
+        attachments: message.attachments?.map((att) => ({
+          filename: att.filename,
+          content: att.content,
+          path: att.path,
+          contentType: att.contentType,
+          cid: att.contentId,
+          contentDisposition: att.contentDisposition
+        })),
+        headers: message.headers,
+        messageId: message.messageId || options?.messageId,
+        date: message.date || options?.date,
+        encoding: options?.encoding,
+        textEncoding: options?.textEncoding,
+        envelope: options?.envelope,
+        priority: options?.priority,
+        dsn: options?.dsn
+      };
+      this.debug("Sending email", {
+        to: mailOptions.to,
+        subject: message.subject
+      });
+      const info = await this.transporter.sendMail(mailOptions);
+      const sendInfo = info;
+      return {
+        messageId: sendInfo.messageId,
+        accepted: sendInfo.accepted,
+        rejected: sendInfo.rejected,
+        response: sendInfo.response
+      };
+    } catch (error) {
+      throw this.mapSMTPError(error);
+    }
+  }
+  /**
+   * Format email address for Nodemailer
+   */
+  formatEmailAddress(addr) {
+    if (addr.name) {
+      const name = addr.name.replace(/"/g, '\\"');
+      return `"${name}" <${addr.address}>`;
+    }
+    return addr.address;
+  }
+  /**
+   * Map Nodemailer/SMTP errors to standard error types
+   */
+  mapSMTPError(error) {
+    if (error instanceof EmailError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      const message = error.message.toLowerCase();
+      if (message.includes("authentication") || message.includes("invalid login") || message.includes("535")) {
+        return new AuthenticationError(error.message, "smtp", error);
+      }
+      if (message.includes("timeout") || message.includes("etimedout")) {
+        return new TimeoutError(error.message, "smtp", error);
+      }
+      if (message.includes("econnrefused") || message.includes("enotfound") || message.includes("connection") || message.includes("ehostunreach")) {
+        return new ConnectionError(error.message, "smtp", error);
+      }
+      if ("accepted" in error && "rejected" in error) {
+        const errorWithRecipients = error;
+        return new SendError(
+          error.message,
+          errorWithRecipients.accepted || [],
+          errorWithRecipients.rejected || [],
+          "smtp",
+          error
+        );
+      }
+      return new EmailError(error.message, "SMTP_ERROR", "smtp", error);
+    }
+    return new EmailError(String(error), "UNKNOWN_ERROR", "smtp");
+  }
+  /**
+   * Connect to SMTP server (verify connection)
+   */
+  async connect() {
+    try {
+      this.debug("Verifying SMTP connection", { host: this.options.host });
+      await this.transporter.verify();
+      this.connected = true;
+      this.debug("SMTP connection verified");
+    } catch (error) {
+      this.connected = false;
+      throw this.mapSMTPError(error);
+    }
+  }
+  /**
+   * Disconnect from SMTP server
+   */
+  async disconnect() {
+    this.transporter.close();
+    this.connected = false;
+    this.debug("SMTP connection closed");
+  }
+  /**
+   * Get adapter capabilities
+   */
+  async getCapabilities() {
+    return {
+      send: true,
+      receive: false,
+      // SMTP is send-only
+      folders: false,
+      search: false,
+      markRead: false,
+      move: false,
+      delete: false,
+      threads: false,
+      oauth: this.isOAuth2()
+    };
+  }
+  /**
+   * Check if using OAuth2 authentication
+   */
+  isOAuth2() {
+    return this.options.auth !== void 0 && "type" in this.options.auth && this.options.auth.type === "OAuth2";
+  }
+  // ========================================================================
+  // Unsupported operations (SMTP is send-only)
+  // ========================================================================
+  async fetch(_options) {
+    throw new EmailError(
+      "SMTP does not support receiving messages. Use IMAP or POP3 adapter.",
+      "UNSUPPORTED_OPERATION",
+      "smtp"
+    );
+  }
+  async getMessage(_messageId) {
+    throw new EmailError(
+      "SMTP does not support receiving messages. Use IMAP or POP3 adapter.",
+      "UNSUPPORTED_OPERATION",
+      "smtp"
+    );
+  }
+  async listFolders() {
+    throw new EmailError(
+      "SMTP does not support folder operations.",
+      "UNSUPPORTED_OPERATION",
+      "smtp"
+    );
+  }
+  async selectFolder(_name) {
+    throw new EmailError(
+      "SMTP does not support folder operations.",
+      "UNSUPPORTED_OPERATION",
+      "smtp"
+    );
+  }
+  async createFolder(_name) {
+    throw new EmailError(
+      "SMTP does not support folder operations.",
+      "UNSUPPORTED_OPERATION",
+      "smtp"
+    );
+  }
+  async deleteFolder(_name) {
+    throw new EmailError(
+      "SMTP does not support folder operations.",
+      "UNSUPPORTED_OPERATION",
+      "smtp"
+    );
+  }
+  async markRead(_messageId) {
+    throw new EmailError(
+      "SMTP does not support message operations.",
+      "UNSUPPORTED_OPERATION",
+      "smtp"
+    );
+  }
+  async markUnread(_messageId) {
+    throw new EmailError(
+      "SMTP does not support message operations.",
+      "UNSUPPORTED_OPERATION",
+      "smtp"
+    );
+  }
+  async move(_messageId, _folder) {
+    throw new EmailError(
+      "SMTP does not support message operations.",
+      "UNSUPPORTED_OPERATION",
+      "smtp"
+    );
+  }
+  async copy(_messageId, _folder) {
+    throw new EmailError(
+      "SMTP does not support message operations.",
+      "UNSUPPORTED_OPERATION",
+      "smtp"
+    );
+  }
+  async delete(_messageId) {
+    throw new EmailError(
+      "SMTP does not support message operations.",
+      "UNSUPPORTED_OPERATION",
+      "smtp"
+    );
+  }
+  async search(_criteria) {
+    throw new EmailError(
+      "SMTP does not support search operations.",
+      "UNSUPPORTED_OPERATION",
+      "smtp"
+    );
+  }
+}
+const smtp = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  SMTPAdapter
+}, Symbol.toStringTag, { value: "Module" }));
+function isSMTPOptions(opts) {
+  return opts.type === "smtp";
+}
+function isIMAPOptions(opts) {
+  return opts.type === "imap";
+}
+function isPOP3Options(opts) {
+  return opts.type === "pop3";
+}
+function isGmailOptions(opts) {
+  return opts.type === "gmail";
+}
+async function getEmailClient(options) {
+  const opts = await loadEnvironmentConfig(options);
+  if (isSMTPOptions(opts)) {
+    const { SMTPAdapter: SMTPAdapter2 } = await Promise.resolve().then(() => smtp);
+    return new SMTPAdapter2(opts);
+  }
+  if (isIMAPOptions(opts)) {
+    const { IMAPAdapter: IMAPAdapter2 } = await Promise.resolve().then(() => imap);
+    return new IMAPAdapter2(opts);
+  }
+  if (isPOP3Options(opts)) {
+    const { POP3Adapter: POP3Adapter2 } = await Promise.resolve().then(() => pop3);
+    return new POP3Adapter2(opts);
+  }
+  if (isGmailOptions(opts)) {
+    const { GmailAdapter: GmailAdapter2 } = await Promise.resolve().then(() => gmail);
+    return new GmailAdapter2(opts);
+  }
+  throw new Error(
+    `Unknown email client type: ${opts.type}`
+  );
+}
+async function loadEnvironmentConfig(options) {
+  if (!options.type && process.env.HAVE_EMAIL_TYPE) {
+    options = {
+      ...options,
+      type: process.env.HAVE_EMAIL_TYPE
+    };
+  }
+  if (options.type === "smtp") {
+    return loadSMTPEnvironmentConfig(options);
+  }
+  if (options.type === "imap") {
+    return loadIMAPEnvironmentConfig(options);
+  }
+  if (options.type === "pop3") {
+    return loadPOP3EnvironmentConfig(options);
+  }
+  if (options.type === "gmail") {
+    return loadGmailEnvironmentConfig(options);
+  }
+  return options;
+}
+function loadSMTPEnvironmentConfig(options) {
+  return {
+    ...options,
+    host: options.host || process.env.HAVE_EMAIL_SMTP_HOST || process.env.HAVE_EMAIL_HOST || "",
+    port: options.port || Number.parseInt(
+      process.env.HAVE_EMAIL_SMTP_PORT || process.env.HAVE_EMAIL_PORT || "587",
+      10
+    ),
+    secure: options.secure ?? (process.env.HAVE_EMAIL_SMTP_SECURE || process.env.HAVE_EMAIL_SECURE) === "true",
+    auth: options.auth || {
+      user: process.env.HAVE_EMAIL_USER || process.env.HAVE_EMAIL_SMTP_USER,
+      pass: process.env.HAVE_EMAIL_PASSWORD || process.env.HAVE_EMAIL_SMTP_PASSWORD
+    },
+    debug: options.debug ?? process.env.HAVE_EMAIL_DEBUG === "true"
+  };
+}
+function loadIMAPEnvironmentConfig(options) {
+  return {
+    ...options,
+    host: options.host || process.env.HAVE_EMAIL_IMAP_HOST || process.env.HAVE_EMAIL_HOST || "",
+    port: options.port || Number.parseInt(
+      process.env.HAVE_EMAIL_IMAP_PORT || process.env.HAVE_EMAIL_PORT || "993",
+      10
+    ),
+    secure: options.secure ?? (process.env.HAVE_EMAIL_IMAP_SECURE || process.env.HAVE_EMAIL_SECURE) === "true",
+    auth: options.auth || {
+      user: process.env.HAVE_EMAIL_USER || process.env.HAVE_EMAIL_IMAP_USER,
+      pass: process.env.HAVE_EMAIL_PASSWORD || process.env.HAVE_EMAIL_IMAP_PASSWORD
+    },
+    debug: options.debug ?? process.env.HAVE_EMAIL_DEBUG === "true"
+  };
+}
+function loadPOP3EnvironmentConfig(options) {
+  return {
+    ...options,
+    host: options.host || process.env.HAVE_EMAIL_POP3_HOST || process.env.HAVE_EMAIL_HOST || "",
+    port: options.port || Number.parseInt(
+      process.env.HAVE_EMAIL_POP3_PORT || process.env.HAVE_EMAIL_PORT || "995",
+      10
+    ),
+    secure: options.secure ?? (process.env.HAVE_EMAIL_POP3_SECURE || process.env.HAVE_EMAIL_SECURE) === "true",
+    auth: options.auth || {
+      user: process.env.HAVE_EMAIL_USER || process.env.HAVE_EMAIL_POP3_USER,
+      pass: process.env.HAVE_EMAIL_PASSWORD || process.env.HAVE_EMAIL_POP3_PASSWORD
+    },
+    debug: options.debug ?? process.env.HAVE_EMAIL_DEBUG === "true"
+  };
+}
+function loadGmailEnvironmentConfig(options) {
+  return {
+    ...options,
+    auth: options.auth || {
+      clientId: process.env.HAVE_EMAIL_GMAIL_CLIENT_ID || "",
+      clientSecret: process.env.HAVE_EMAIL_GMAIL_CLIENT_SECRET || "",
+      refreshToken: process.env.HAVE_EMAIL_GMAIL_REFRESH_TOKEN || "",
+      accessToken: process.env.HAVE_EMAIL_GMAIL_ACCESS_TOKEN
+    },
+    userId: options.userId || process.env.HAVE_EMAIL_GMAIL_USER_ID || "me",
+    debug: options.debug ?? process.env.HAVE_EMAIL_DEBUG === "true"
+  };
+}
+export {
+  AttachmentError,
+  AuthenticationError,
+  AuthorizationError,
+  BaseEmailClient,
+  ConnectionError,
+  EmailError,
+  FolderExistsError,
+  FolderNotFoundError,
+  GmailAdapter,
+  IMAPAdapter,
+  InvalidMessageError,
+  MessageNotFoundError,
+  POP3Adapter,
+  SMTPAdapter,
+  SendError,
+  TimeoutError,
+  getEmailClient,
+  isGmailOptions,
+  isIMAPOptions,
+  isPOP3Options,
+  isSMTPOptions
+};
+//# sourceMappingURL=index.js.map