react-native-email-imap-smtp 0.1.0

package/windows/EmailImapSmtp.cpp

@@ -0,0 +1,735 @@
+// ============================================================
+// EmailImapSmtp.cpp — Nitro HybridObject 桥接层
+// 将 Nitro struct ↔ emailimap:: struct 转换，委托协议层
+// ============================================================
+
+#include "EmailImapSmtp.h"
+#include "ImapProtocol.h"
+#include "SmtpProtocol.h"
+
+#include <chrono>
+#include <thread>
+
+namespace margelo::nitro::emailimapsmtp {
+
+// ═══════════════════════════════════════════════════════════
+//  Conversion helpers: Nitro → emailimap:: (toProto)
+// ═══════════════════════════════════════════════════════════
+
+static emailimap::ConnectionConfig toProto(const ConnectionConfig& src) {
+  emailimap::ConnectionConfig dst;
+  dst.host     = src.host;
+  dst.port     = src.port;
+  dst.username = src.username;
+  dst.password = src.password;
+  dst.tls      = src.tls;
+  dst.authType = src.authType;
+  dst.accessToken = src.accessToken;
+  dst.timeout  = src.timeout;
+  dst.checkCertificate = src.checkCertificate;
+  dst.debug    = src.debug;
+  return dst;
+}
+
+static emailimap::SmtpConnectionConfig toProto(const SmtpConnectionConfig& src) {
+  emailimap::SmtpConnectionConfig dst;
+  dst.host     = src.host;
+  dst.port     = src.port;
+  dst.username = src.username;
+  dst.password = src.password;
+  dst.tls      = src.tls;
+  dst.authType = src.authType;
+  dst.accessToken = src.accessToken;
+  dst.timeout  = src.timeout;
+  dst.checkCertificate = src.checkCertificate;
+  dst.helloName = src.helloName;
+  dst.debug    = src.debug;
+  return dst;
+}
+
+static emailimap::FetchEmailsOptions toProto(const FetchEmailsOptions& src) {
+  emailimap::FetchEmailsOptions dst;
+  dst.mailbox     = src.mailbox;
+  dst.from        = src.from;
+  dst.to          = src.to;
+  dst.rangeType   = src.rangeType;
+  dst.page        = src.page;
+  dst.pageSize    = src.pageSize;
+  dst.since       = src.since;
+  dst.before      = src.before;
+  dst.fetchBody   = src.fetchBody;
+  dst.fetchAttachments = src.fetchAttachments;
+  dst.fetchFlags  = src.fetchFlags;
+  dst.fetchHeaders = src.fetchHeaders;
+  dst.fetchFullContent = src.fetchFullContent;
+  dst.maxBodySize = src.maxBodySize;
+  return dst;
+}
+
+static emailimap::SearchCriteria toProto(const SearchCriteria& src) {
+  emailimap::SearchCriteria dst;
+  dst.text        = src.text;
+  dst.subject    = src.subject;
+  dst.from       = src.from;
+  dst.to         = src.to;
+  dst.body       = src.body;
+  dst.since      = src.since;
+  dst.before     = src.before;
+  dst.on         = src.on;
+  dst.sentSince  = src.sentSince;
+  dst.sentBefore = src.sentBefore;
+  dst.flagged    = src.flagged;
+  dst.seen       = src.seen;
+  dst.answered   = src.answered;
+  dst.draft      = src.draft;
+  dst.deleted    = src.deleted;
+  dst.junk       = src.junk;
+  dst.hasAttachment = src.hasAttachment;
+  dst.uids       = src.uids;
+  if (src.header.has_value()) {
+    emailimap::SearchHeader h;
+    h.key = src.header.value().key;
+    h.value = src.header.value().value;
+    dst.header = h;
+  }
+  dst.larger     = src.larger;
+  dst.smaller    = src.smaller;
+  dst.mailbox    = src.mailbox;
+  dst.sortOrder  = src.sortOrder;
+  dst.limit      = src.limit;
+  dst.fetchBody   = src.fetchBody;
+  dst.fetchAttachments = src.fetchAttachments;
+  dst.fetchFlags  = src.fetchFlags;
+  dst.fetchHeaders = src.fetchHeaders;
+  dst.fetchFullContent = src.fetchFullContent;
+  dst.maxBodySize = src.maxBodySize;
+  return dst;
+}
+
+static emailimap::SendMailOptions toProto(const SendMailOptions& src) {
+  emailimap::SendMailOptions dst;
+  dst.from.name  = src.from.name;
+  dst.from.email = src.from.email;
+  for (const auto& a : src.to) {
+    emailimap::EmailAddress addr;
+    addr.name = a.name; addr.email = a.email;
+    dst.to.push_back(addr);
+  }
+  if (src.cc.has_value()) {
+    std::vector<emailimap::EmailAddress> cc;
+    for (const auto& a : src.cc.value()) {
+      emailimap::EmailAddress addr;
+      addr.name = a.name; addr.email = a.email;
+      cc.push_back(addr);
+    }
+    dst.cc = cc;
+  }
+  if (src.bcc.has_value()) {
+    std::vector<emailimap::EmailAddress> bcc;
+    for (const auto& a : src.bcc.value()) {
+      emailimap::EmailAddress addr;
+      addr.name = a.name; addr.email = a.email;
+      bcc.push_back(addr);
+    }
+    dst.bcc = bcc;
+  }
+  dst.subject  = src.subject;
+  dst.textBody = src.textBody;
+  dst.htmlBody = src.htmlBody;
+  if (src.attachments.has_value()) {
+    std::vector<emailimap::SmtpAttachment> atts;
+    for (const auto& a : src.attachments.value()) {
+      emailimap::SmtpAttachment att;
+      att.filename = a.filename;
+      att.mimeType = a.mimeType;
+      if (a.data) {
+        att.data.assign(a.data->data(), a.data->data() + a.data->size());
+      }
+      att.contentId = a.contentId;
+      att.isInline = a.isInline;
+      att.disposition = a.disposition;
+      atts.push_back(att);
+    }
+    dst.attachments = atts;
+  }
+  if (src.replyTo.has_value()) {
+    std::vector<emailimap::EmailAddress> replyTo;
+    for (const auto& a : src.replyTo.value()) {
+      emailimap::EmailAddress addr;
+      addr.name = a.name; addr.email = a.email;
+      replyTo.push_back(addr);
+    }
+    dst.replyTo = replyTo;
+  }
+  dst.priority      = src.priority;
+  dst.headers       = src.headers;
+  dst.inReplyTo     = src.inReplyTo;
+  dst.references    = src.references;
+  dst.charset       = src.charset;
+  dst.encoding      = src.encoding;
+  if (src.readReceiptTo.has_value()) {
+    emailimap::EmailAddress addr;
+    addr.name = src.readReceiptTo.value().name;
+    addr.email = src.readReceiptTo.value().email;
+    dst.readReceiptTo = addr;
+  }
+  return dst;
+}
+
+// ═══════════════════════════════════════════════════════════
+//  Conversion helpers: emailimap:: → Nitro (toNitro)
+// ═══════════════════════════════════════════════════════════
+
+static ConnectionResult toNitro(const emailimap::ConnectionResult& src) {
+  ConnectionResult dst;
+  dst.success = src.success;
+  dst.error   = src.error;
+  // serverInfo is set directly by callers (imapConnect/smtpConnect)
+  // since Nitro uses variant<ImapServerInfo, SmtpServerInfo>.
+  return dst;
+}
+
+static MailboxListItem toNitro(const emailimap::MailboxListItem& src) {
+  MailboxListItem dst;
+  dst.name       = src.name;
+  dst.path       = src.path;
+  dst.delimiter  = src.delimiter;
+  dst.flags      = src.flags;
+  dst.subscribed = src.subscribed;
+  return dst;
+}
+
+static MailboxInfo toNitro(const emailimap::MailboxInfo& src) {
+  MailboxInfo dst;
+  dst.name           = src.name;
+  dst.path           = src.path;
+  dst.uidNext        = src.uidNext;
+  dst.uidValidity    = src.uidValidity;
+  dst.messageCount   = src.messageCount;
+  dst.recentCount    = src.recentCount;
+  dst.unseenCount    = src.unseenCount;
+  dst.firstUnseenUid = src.firstUnseenUid;
+  dst.highestModSeq  = src.highestModSeq;
+  dst.flags          = src.flags;
+  dst.permanentFlags = src.permanentFlags;
+  return dst;
+}
+
+static FolderInfo toNitro(const emailimap::FolderInfo& src) {
+  FolderInfo dst;
+  dst.name         = src.name;
+  dst.path         = src.path;
+  dst.delimiter    = src.delimiter;
+  dst.parent       = src.parent;
+  dst.children     = src.children;
+  dst.flags        = src.flags;
+  dst.subscribed   = src.subscribed;
+  dst.messageCount = src.messageCount;
+  dst.unseenCount  = src.unseenCount;
+  return dst;
+}
+
+static EmailAddress toNitro(const emailimap::EmailAddress& src) {
+  EmailAddress dst;
+  dst.name  = src.name;
+  dst.email = src.email;
+  return dst;
+}
+
+static EmailBody toNitro(const emailimap::EmailBody& src) {
+  EmailBody dst;
+  dst.text   = src.text;
+  dst.html   = src.html;
+  dst.embeddedAttachments = src.embeddedAttachments;
+  return dst;
+}
+
+static AttachmentInfo toNitro(const emailimap::AttachmentInfo& src) {
+  AttachmentInfo dst;
+  dst.filename    = src.filename;
+  dst.mimeType    = src.mimeType;
+  dst.partId      = src.partId;
+  dst.size        = src.size;
+  // vector<uint8_t> → ArrayBuffer
+  if (!src.data.empty()) {
+    dst.data = ArrayBuffer::copy(src.data.data(), src.data.size());
+  } else {
+    dst.data = ArrayBuffer::copy(nullptr, 0);
+  }
+  dst.contentId        = src.contentId;
+  dst.isInline         = src.isInline;
+  dst.charset          = src.charset;
+  dst.contentDisposition = src.contentDisposition;
+  dst.localPath        = src.localPath;
+  return dst;
+}
+
+static EmailMessage toNitro(const emailimap::EmailMessage& src) {
+  EmailMessage dst;
+  dst.uid            = src.uid;
+  dst.sequenceNumber = src.sequenceNumber;
+  dst.subject        = src.subject;
+  dst.from           = toNitro(src.from);
+  for (const auto& a : src.to)     dst.to.push_back(toNitro(a));
+  for (const auto& a : src.cc)     dst.cc.push_back(toNitro(a));
+  for (const auto& a : src.bcc)    dst.bcc.push_back(toNitro(a));
+  for (const auto& a : src.replyTo) dst.replyTo.push_back(toNitro(a));
+  dst.date         = src.date;
+  dst.receivedDate = src.receivedDate;
+  dst.messageId    = src.messageId;
+  dst.inReplyTo    = src.inReplyTo;
+  dst.references   = src.references;
+  dst.body         = toNitro(src.body);
+  for (const auto& a : src.attachments) dst.attachments.push_back(toNitro(a));
+  dst.flags       = src.flags;
+  dst.mimeType    = src.mimeType;
+  dst.charset     = src.charset;
+  dst.priority    = src.priority;
+  dst.isEncrypted = src.isEncrypted;
+  dst.headers     = src.headers;
+  dst.size        = src.size;
+  return dst;
+}
+
+static DeleteResult toNitro(const emailimap::DeleteResult& src) {
+  DeleteResult dst;
+  dst.success = src.success;
+  dst.failed  = src.failed;
+  dst.error   = src.error;
+  return dst;
+}
+
+static QuotaInfo toNitro(const emailimap::QuotaInfo& src) {
+  QuotaInfo dst;
+  dst.storageUsed    = src.storageUsed;
+  dst.storageLimit   = src.storageLimit;
+  dst.storageUnit    = src.storageUnit;
+  dst.messagesUsed   = src.messagesUsed;
+  dst.messagesLimit  = src.messagesLimit;
+  dst.root           = src.root;
+  return dst;
+}
+
+static AppendResult toNitro(const emailimap::AppendResult& src) {
+  AppendResult dst;
+  dst.uid         = src.uid;
+  dst.uidValidity = src.uidValidity;
+  dst.date        = src.date;
+  return dst;
+}
+
+static SendMailResult toNitro(const emailimap::SendMailResult& src) {
+  SendMailResult dst;
+  dst.success            = src.success;
+  dst.messageId          = src.messageId;
+  dst.date               = src.date;
+  dst.serverResponseCode = src.serverResponseCode;
+  if (src.rawMimeData.has_value() && !src.rawMimeData.value().empty()) {
+    dst.rawMimeData = ArrayBuffer::copy(
+      src.rawMimeData.value().data(),
+      src.rawMimeData.value().size());
+  }
+  dst.queueId    = src.queueId;
+  dst.error      = src.error;
+  dst.retryable  = src.retryable;
+  return dst;
+}
+
+// ═══════════════════════════════════════════════════════════
+//  EmailImapSmtp — HybridObject Implementation
+// ═══════════════════════════════════════════════════════════
+
+EmailImapSmtp::EmailImapSmtp()
+  : HybridObject(TAG)
+  , m_imapClient(std::make_unique<emailimap::ImapClient>())
+  , m_smtpClient(std::make_unique<emailimap::SmtpClient>())
+  , m_keepAliveRunning(false)
+  , m_idling(false)
+{
+}
+
+EmailImapSmtp::~EmailImapSmtp() {
+  stopKeepAlive();
+}
+
+// ─── Keep-Alive ─────────────────────────────────────────────
+
+void EmailImapSmtp::startKeepAlive() {
+  stopKeepAlive();
+  m_keepAliveRunning = true;
+  m_keepAliveThread = std::make_unique<std::thread>([this]() {
+    while (m_keepAliveRunning) {
+      std::this_thread::sleep_for(std::chrono::seconds(60));
+      if (!m_keepAliveRunning) break;
+      if (m_imapClient && m_imapClient->isConnected()) {
+        std::string response, error;
+        m_imapClient->sendCommand("NOOP", response, error);
+      }
+    }
+  });
+  m_keepAliveThread->detach();
+}
+
+void EmailImapSmtp::stopKeepAlive() {
+  m_keepAliveRunning = false;
+  if (m_keepAliveThread && m_keepAliveThread->joinable()) {
+    m_keepAliveThread->join();
+  }
+  m_keepAliveThread.reset();
+}
+
+// ═══ IMAP Methods ═══════════════════════════════════════════
+
+std::shared_ptr<Promise<ConnectionResult>> EmailImapSmtp::imapConnect(const ConnectionConfig& config) {
+  return Promise::async([this, config]() -> ConnectionResult {
+    std::string error;
+    if (m_imapClient->connect(toProto(config), error)) {
+      ConnectionResult result;
+      result.success = true;
+      ImapServerInfo serverInfo;
+      serverInfo.serverName = config.host;
+      serverInfo.isCompressed = false;
+      result.serverInfo = serverInfo;
+      return result;
+    }
+    ConnectionResult result;
+    result.success = false;
+    result.error = error;
+    return result;
+  });
+}
+
+std::shared_ptr<Promise<void>> EmailImapSmtp::imapDisconnect() {
+  return Promise::async([this]() {
+    stopKeepAlive();
+    m_imapClient->disconnect();
+  });
+}
+
+std::shared_ptr<Promise<std::vector<MailboxListItem>>> EmailImapSmtp::imapListMailboxes() {
+  return Promise::async([this]() -> std::vector<MailboxListItem> {
+    std::string error;
+    auto list = m_imapClient->listMailboxes(error);
+    std::vector<MailboxListItem> result;
+    for (const auto& item : list) result.push_back(toNitro(item));
+    return result;
+  });
+}
+
+std::shared_ptr<Promise<MailboxInfo>> EmailImapSmtp::imapSelectMailbox(const std::string& mailbox, bool readOnly) {
+  return Promise::async([this, mailbox, readOnly]() -> MailboxInfo {
+    std::string error;
+    auto info = m_imapClient->selectMailbox(mailbox, readOnly, error);
+    startKeepAlive();
+    return toNitro(info);
+  });
+}
+
+std::shared_ptr<Promise<MailboxInfo>> EmailImapSmtp::imapRefreshMailbox() {
+  return Promise::async([this]() -> MailboxInfo {
+    std::string error;
+    return toNitro(m_imapClient->refreshMailbox(error));
+  });
+}
+
+std::shared_ptr<Promise<std::vector<FolderInfo>>> EmailImapSmtp::imapFetchFolders() {
+  return Promise::async([this]() -> std::vector<FolderInfo> {
+    std::string error;
+    auto list = m_imapClient->fetchFolders(error);
+    std::vector<FolderInfo> result;
+    for (const auto& f : list) result.push_back(toNitro(f));
+    return result;
+  });
+}
+
+std::shared_ptr<Promise<void>> EmailImapSmtp::imapCreateFolder(const std::string& folderName) {
+  return Promise::async([this, folderName]() {
+    std::string error;
+    if (!m_imapClient->createFolder(folderName, error)) {
+      throw std::runtime_error(error);
+    }
+  });
+}
+
+std::shared_ptr<Promise<void>> EmailImapSmtp::imapDeleteFolder(const std::string& folderName) {
+  return Promise::async([this, folderName]() {
+    std::string error;
+    if (!m_imapClient->deleteFolder(folderName, error)) {
+      throw std::runtime_error(error);
+    }
+  });
+}
+
+std::shared_ptr<Promise<void>> EmailImapSmtp::imapRenameFolder(const std::string& oldName, const std::string& newName) {
+  return Promise::async([this, oldName, newName]() {
+    std::string error;
+    if (!m_imapClient->renameFolder(oldName, newName, error)) {
+      throw std::runtime_error(error);
+    }
+  });
+}
+
+std::shared_ptr<Promise<void>> EmailImapSmtp::imapSubscribeFolder(const std::string& folderName) {
+  return Promise::async([this, folderName]() {
+    std::string error;
+    if (!m_imapClient->subscribeFolder(folderName, error)) {
+      throw std::runtime_error(error);
+    }
+  });
+}
+
+std::shared_ptr<Promise<void>> EmailImapSmtp::imapUnsubscribeFolder(const std::string& folderName) {
+  return Promise::async([this, folderName]() {
+    std::string error;
+    if (!m_imapClient->unsubscribeFolder(folderName, error)) {
+      throw std::runtime_error(error);
+    }
+  });
+}
+
+std::shared_ptr<Promise<std::vector<EmailMessage>>> EmailImapSmtp::imapFetchEmails(const FetchEmailsOptions& options) {
+  return Promise::async([this, options]() -> std::vector<EmailMessage> {
+    std::string error;
+    auto list = m_imapClient->fetchEmails(toProto(options), error);
+    std::vector<EmailMessage> result;
+    for (const auto& e : list) result.push_back(toNitro(e));
+    return result;
+  });
+}
+
+std::shared_ptr<Promise<std::variant<NullType, EmailMessage>>> EmailImapSmtp::imapFetchEmailByUID(double uid) {
+  return Promise::async([this, uid]() -> std::variant<NullType, EmailMessage> {
+    std::string error;
+    auto* msg = m_imapClient->fetchEmailByUID(uid, error);
+    if (msg) {
+      auto result = toNitro(*msg);
+      delete msg;
+      return result;
+    }
+    return NullType{};
+  });
+}
+
+std::shared_ptr<Promise<std::vector<EmailMessage>>> EmailImapSmtp::imapSearchEmails(const SearchCriteria& criteria) {
+  return Promise::async([this, criteria]() -> std::vector<EmailMessage> {
+    std::string error;
+    auto list = m_imapClient->searchEmails(toProto(criteria), error);
+    std::vector<EmailMessage> result;
+    for (const auto& e : list) result.push_back(toNitro(e));
+    return result;
+  });
+}
+
+// 匹配 Android 行为：逐条处理，部分失败不抛异常
+std::shared_ptr<Promise<void>> EmailImapSmtp::imapMarkAsRead(const std::vector<double>& uids, bool silent) {
+  return Promise::async([this, uids, silent]() {
+    for (double uid : uids) {
+      std::string error;
+      m_imapClient->markAsRead({uid}, silent, error);
+    }
+  });
+}
+
+std::shared_ptr<Promise<void>> EmailImapSmtp::imapMarkAsFlagged(const std::vector<double>& uids, bool flagged) {
+  return Promise::async([this, uids, flagged]() {
+    for (double uid : uids) {
+      std::string error;
+      m_imapClient->markAsFlagged({uid}, flagged, error);
+    }
+  });
+}
+
+std::shared_ptr<Promise<void>> EmailImapSmtp::imapMoveEmails(const std::vector<double>& uids, const std::string& destinationMailbox) {
+  return Promise::async([this, uids, destinationMailbox]() {
+    std::string error;
+    if (!m_imapClient->moveEmails(uids, destinationMailbox, error)) {
+      throw std::runtime_error(error);
+    }
+  });
+}
+
+std::shared_ptr<Promise<void>> EmailImapSmtp::imapCopyEmails(const std::vector<double>& uids, const std::string& destinationMailbox) {
+  return Promise::async([this, uids, destinationMailbox]() {
+    std::string error;
+    if (!m_imapClient->copyEmails(uids, destinationMailbox, error)) {
+      throw std::runtime_error(error);
+    }
+  });
+}
+
+std::shared_ptr<Promise<DeleteResult>> EmailImapSmtp::imapDeleteEmails(const std::vector<double>& uids) {
+  return Promise::async([this, uids]() -> DeleteResult {
+    std::string error;
+    return toNitro(m_imapClient->deleteEmails(uids, error));
+  });
+}
+
+std::shared_ptr<Promise<void>> EmailImapSmtp::imapExpunge() {
+  return Promise::async([this]() {
+    std::string error;
+    if (!m_imapClient->expunge(error)) {
+      throw std::runtime_error(error);
+    }
+  });
+}
+
+std::shared_ptr<Promise<std::variant<NullType, AttachmentInfo>>> EmailImapSmtp::imapFetchAttachments(double uid, const std::string& partId) {
+  return Promise::async([this, uid, partId]() -> std::variant<NullType, AttachmentInfo> {
+    std::string error;
+    auto* att = m_imapClient->fetchAttachment(uid, partId, error);
+    if (att) {
+      auto result = toNitro(*att);
+      delete att;
+      return result;
+    }
+    return NullType{};
+  });
+}
+
+std::shared_ptr<Promise<std::vector<AttachmentInfo>>> EmailImapSmtp::imapFetchAllAttachments(double uid) {
+  return Promise::async([this, uid]() -> std::vector<AttachmentInfo> {
+    std::string error;
+    auto list = m_imapClient->fetchAllAttachments(uid, error);
+    std::vector<AttachmentInfo> result;
+    for (const auto& a : list) result.push_back(toNitro(a));
+    return result;
+  });
+}
+
+std::shared_ptr<Promise<void>> EmailImapSmtp::imapIdle(const std::function<void(const IdleNotification&)>& callback) {
+  return Promise::async([this, callback]() {
+    m_idling = true;
+    m_idleCallback = callback;
+
+    // Wrap callback to convert emailimap::IdleNotification → Nitro IdleNotification
+    auto protoCallback = [this](const emailimap::IdleNotification& protoNote) {
+      if (m_idleCallback) {
+        IdleNotification nitroNote;
+        nitroNote.type = protoNote.type;
+        nitroNote.mailbox = protoNote.mailbox;
+        nitroNote.uid = protoNote.uid;
+        nitroNote.flag = protoNote.flag;
+        nitroNote.messageCount = protoNote.messageCount;
+        nitroNote.timestamp = protoNote.timestamp;
+        m_idleCallback(nitroNote);
+      }
+    };
+
+    std::string error;
+    if (!m_imapClient->idle(protoCallback, error)) {
+      m_idling = false;
+      throw std::runtime_error(error);
+    }
+
+    {
+      std::unique_lock<std::mutex> lock(m_idleMutex);
+      m_idleCV.wait(lock, [this]() { return !m_idling || !m_imapClient->isConnected(); });
+    }
+
+    if (!m_imapClient->isConnected() && m_idleCallback) {
+      IdleNotification notification;
+      notification.type = "connectionLost";
+      notification.mailbox = "";
+      notification.timestamp = static_cast<double>(
+        std::chrono::duration_cast<std::chrono::milliseconds>(
+          std::chrono::system_clock::now().time_since_epoch()).count());
+      m_idleCallback(notification);
+    }
+    m_idling = false;
+  });
+}
+
+std::shared_ptr<Promise<void>> EmailImapSmtp::imapStopIdle() {
+  return Promise::async([this]() {
+    m_idling = false;
+    std::string error;
+    m_imapClient->stopIdle(error);
+    m_idleCV.notify_one();
+  });
+}
+
+std::shared_ptr<Promise<QuotaInfo>> EmailImapSmtp::imapGetQuota(const std::optional<std::string>& root) {
+  return Promise::async([this, root]() -> QuotaInfo {
+    std::string error;
+    return toNitro(m_imapClient->getQuota(root, error));
+  });
+}
+
+std::shared_ptr<Promise<AppendResult>> EmailImapSmtp::imapAppendMessage(
+    const std::string& mailbox,
+    const std::shared_ptr<ArrayBuffer>& rawMimeData,
+    const std::optional<std::vector<std::string>>& flags) {
+  return Promise::async([this, mailbox, rawMimeData, flags]() -> AppendResult {
+    // Convert ArrayBuffer → vector<uint8_t> on JS thread (Nitro requirement)
+    std::vector<uint8_t> mimeData;
+    if (rawMimeData) {
+      mimeData.assign(rawMimeData->data(), rawMimeData->data() + rawMimeData->size());
+    }
+    std::string error;
+    return toNitro(m_imapClient->appendMessage(mailbox, mimeData, flags, error));
+  });
+}
+
+// ═══ SMTP Methods ═══════════════════════════════════════════
+
+std::shared_ptr<Promise<ConnectionResult>> EmailImapSmtp::smtpConnect(const SmtpConnectionConfig& config) {
+  return Promise::async([this, config]() -> ConnectionResult {
+    std::string error;
+    auto protoConfig = toProto(config);
+    if (m_smtpClient->connect(protoConfig, error)) {
+      m_smtpConfig = protoConfig;
+      ConnectionResult result;
+      result.success = true;
+      SmtpServerInfo serverInfo;
+      serverInfo.serverName = config.host;
+      serverInfo.supportedAuthMethods = {"LOGIN", "PLAIN"};
+      result.serverInfo = serverInfo;
+      return result;
+    }
+    ConnectionResult result;
+    result.success = false;
+    result.error = error;
+    return result;
+  });
+}
+
+std::shared_ptr<Promise<void>> EmailImapSmtp::smtpDisconnect() {
+  return Promise::async([this]() {
+    m_smtpClient->disconnect();
+    m_smtpConfig.reset();
+  });
+}
+
+std::shared_ptr<Promise<SendMailResult>> EmailImapSmtp::smtpSendMail(const SendMailOptions& options) {
+  return Promise::async([this, options]() -> SendMailResult {
+    emailimap::SendMailResult protoResult;
+    std::string error;
+
+    if (!m_smtpConfig.has_value()) {
+      protoResult.success = false;
+      protoResult.error = "SMTP not configured. Call smtpConnect first.";
+      protoResult.retryable = true;
+      return toNitro(protoResult);
+    }
+
+    // 匹配 Android 行为：每次发送创建临时连接，发完保留连接供 verify 检查
+    m_smtpClient->disconnect();
+    if (m_smtpClient->connect(m_smtpConfig.value(), error)) {
+      m_smtpClient->sendMail(toProto(options), protoResult, error);
+      // 不 disconnect：保持连接状态，供 smtpVerifyConnection 检查（匹配 Android）
+    } else {
+      protoResult.success = false;
+      protoResult.error = error;
+      protoResult.retryable = true;
+    }
+    return toNitro(protoResult);
+  });
+}
+
+std::shared_ptr<Promise<bool>> EmailImapSmtp::smtpVerifyConnection() {
+  return Promise::async([this]() -> bool {
+    return m_smtpClient->isConnected();
+  });
+}
+
+} // namespace margelo::nitro::emailimapsmtp