react-native-email-imap-smtp 0.1.0

package/windows/ImapProtocol.cpp

@@ -0,0 +1,1382 @@
+// ============================================================
+// ImapProtocol.cpp — 纯 IMAP 协议实现
+// 从 EmailImapSmtp.cpp 拆分，移除所有 Nitro/JSI 依赖
+// ============================================================
+
+#include "ImapProtocol.h"
+
+#include <sstream>
+#include <cstring>
+#include <chrono>
+#include <random>
+#include <array>
+#include <thread>
+#include <ctime>
+#include <iomanip>
+
+namespace emailimap {
+
+// ═══════════════════════════════════════════════════════════
+//  IMAP modified UTF-7 decoder (RFC 3501)
+// ═══════════════════════════════════════════════════════════
+
+static int utf16ToUtf8(uint16_t u16, char* out) {
+  if (u16 < 0x80) { out[0] = (char)u16; return 1; }
+  if (u16 < 0x800) { out[0] = (char)(0xC0 | (u16 >> 6)); out[1] = (char)(0x80 | (u16 & 0x3F)); return 2; }
+  out[0] = (char)(0xE0 | (u16 >> 12));
+  out[1] = (char)(0x80 | ((u16 >> 6) & 0x3F));
+  out[2] = (char)(0x80 | (u16 & 0x3F));
+  return 3;
+}
+
+static std::string decodeImapUtf7(const std::string& s) {
+  std::string result;
+  size_t i = 0;
+  while (i < s.size()) {
+    if (s[i] == '&') {
+      size_t end = s.find('-', i + 1);
+      if (end == std::string::npos) { result += s[i]; i++; continue; }
+      if (end == i + 1) {
+        // &- → literal &
+        result += '&';
+        i = end + 1;
+        continue;
+      }
+      // &base64- → decode
+      std::string b64 = s.substr(i + 1, end - i - 1);
+      // IMAP UTF-7 uses ',' instead of '/' in base64
+      for (char& c : b64) if (c == ',') c = '/';
+      std::vector<char> raw = decodeBase64(b64);
+      // raw bytes are UTF-16BE
+      for (size_t j = 0; j + 1 < raw.size(); j += 2) {
+        uint16_t u16 = (uint16_t)(unsigned char)raw[j] << 8 | (unsigned char)raw[j+1];
+        // Check for surrogate pair (U+D800-U+DBFF = high, U+DC00-U+DFFF = low)
+        if (u16 >= 0xD800 && u16 <= 0xDBFF && j + 3 < raw.size()) {
+          uint16_t lo = (uint16_t)(unsigned char)raw[j+2] << 8 | (unsigned char)raw[j+3];
+          if (lo >= 0xDC00 && lo <= 0xDFFF) {
+            uint32_t cp = 0x10000 + (u16 - 0xD800) * 0x400 + (lo - 0xDC00);
+            char buf[4];
+            buf[0] = (char)(0xF0 | (cp >> 18));
+            buf[1] = (char)(0x80 | ((cp >> 12) & 0x3F));
+            buf[2] = (char)(0x80 | ((cp >> 6) & 0x3F));
+            buf[3] = (char)(0x80 | (cp & 0x3F));
+            result.append(buf, 4);
+            j += 2;
+            continue;
+          }
+        }
+        char buf[4];
+        int n = utf16ToUtf8(u16, buf);
+        result.append(buf, n);
+      }
+      i = end + 1;
+      continue;
+    }
+    // Printable ASCII (except &, which is handled above)
+    result += s[i];
+    i++;
+  }
+  return result;
+}
+
+// ═══════════════════════════════════════════════════════════
+//  MIME Parsing helpers
+//  (Utility functions trim/toUpper/split/currentTimestamp/formatDate
+//   are defined in TlsSocket.cpp - shared by ImapProtocol and SmtpProtocol)
+// ═══════════════════════════════════════════════════════════
+
+std::string ImapClient::decodeMimeHeader(const std::string& header) {
+  std::string result = header;
+  std::regex pattern("=\\?([^?]+)\\?([BbQq])\\?([^?]*)\\?=");
+  std::smatch match;
+
+  while (std::regex_search(result, match, pattern)) {
+    std::string charset = match[1];
+    std::string encoding = toUpper(match[2].str());
+    std::string encoded = match[3];
+
+    std::string decoded;
+    if (encoding == "B") {
+      auto bytes = decodeBase64(encoded);
+      decoded = std::string(bytes.begin(), bytes.end());
+    } else if (encoding == "Q") {
+      for (size_t i = 0; i < encoded.size(); i++) {
+        if (encoded[i] == '_') {
+          decoded += ' ';
+        } else if (encoded[i] == '=' && i + 2 < encoded.size()) {
+          std::string hex = encoded.substr(i + 1, 2);
+          decoded += static_cast<char>(std::stoi(hex, nullptr, 16));
+          i += 2;
+        } else {
+          decoded += encoded[i];
+        }
+      }
+    } else {
+      decoded = encoded;
+    }
+
+    result.replace(match.position(), match.length(), decoded);
+  }
+
+  return result;
+}
+
+std::string ImapClient::decodeQuotedPrintable(const std::string& text) {
+  std::string result;
+  for (size_t i = 0; i < text.size(); i++) {
+    if (text[i] == '=' && i + 2 < text.size()) {
+      if (text[i + 1] == '\r' && text[i + 2] == '\n') {
+        i += 2;
+        continue;
+      }
+      if (text[i + 1] == '\n') {
+        i += 1;
+        continue;
+      }
+      std::string hex = text.substr(i + 1, 2);
+      result += static_cast<char>(std::stoi(hex, nullptr, 16));
+      i += 2;
+    } else {
+      result += text[i];
+    }
+  }
+  return result;
+}
+
+void ImapClient::parseMimeParts(const std::string& contentType, const std::string& body,
+                                 std::string& textBody, std::string& htmlBody,
+                                 std::vector<AttachmentInfo>& attachments) {
+  std::string ct = toUpper(contentType);
+
+  if (ct.find("TEXT/PLAIN") != std::string::npos) {
+    textBody = body;
+  } else if (ct.find("TEXT/HTML") != std::string::npos) {
+    htmlBody = body;
+  } else if (ct.find("MULTIPART/ALTERNATIVE") != std::string::npos ||
+             ct.find("MULTIPART/MIXED") != std::string::npos ||
+             ct.find("MULTIPART/RELATED") != std::string::npos) {
+    std::string boundary;
+    std::regex boundaryRegex(R"re(boundary\s*=\s*"?([^";\s]+)"?)re", std::regex::icase);
+    std::smatch match;
+    if (std::regex_search(contentType, match, boundaryRegex) && match.size() > 1) {
+      boundary = match[1];
+    } else {
+      textBody = body;
+      return;
+    }
+
+    std::string delimiter = "--" + boundary;
+    std::vector<std::string> parts;
+    size_t pos = 0;
+    while (true) {
+      size_t found = body.find(delimiter, pos);
+      if (found == std::string::npos) break;
+      size_t next = body.find("\n", found);
+      if (next == std::string::npos) break;
+      size_t partEnd = body.find(delimiter, next + 1);
+      if (partEnd == std::string::npos) {
+        parts.push_back(body.substr(next + 1));
+        break;
+      }
+      parts.push_back(body.substr(next + 1, partEnd - next - 1));
+      pos = partEnd;
+    }
+
+    for (const auto& part : parts) {
+      size_t headerEnd = part.find("\r\n\r\n");
+      if (headerEnd == std::string::npos) {
+        headerEnd = part.find("\n\n");
+      }
+      if (headerEnd == std::string::npos) continue;
+
+      std::string partHeaders = part.substr(0, headerEnd);
+      std::string partBody = part.substr(headerEnd + 2);
+
+      std::string partCt = "text/plain";
+      std::regex ctRegex(R"x(Content-Type:\s*(.+?)(?:\r?\n|$))x", std::regex::icase);
+      std::smatch ctMatch;
+      if (std::regex_search(partHeaders, ctMatch, ctRegex) && ctMatch.size() > 1) {
+        partCt = trim(ctMatch[1]);
+      }
+      parseMimeParts(partCt, partBody, textBody, htmlBody, attachments);
+    }
+  } else {
+    // Attachment or unknown content type
+    AttachmentInfo info;
+    info.filename = "attachment";
+    info.mimeType = contentType;
+    info.partId = "1";
+    info.size = static_cast<double>(body.size());
+    info.data.assign(body.begin(), body.end()); // ArrayBuffer::copy → vector<uint8_t>
+    info.contentId = std::nullopt;
+    info.isInline = false;
+    info.charset = std::nullopt;
+    info.contentDisposition = "attachment";
+    info.localPath = std::nullopt;
+    attachments.push_back(info);
+  }
+}
+
+EmailMessage ImapClient::parseMessage(const std::string& rawHeaders, const std::string& rawBody,
+                                       double uid, double seqNum) {
+  EmailMessage msg;
+  msg.uid = uid;
+  msg.sequenceNumber = seqNum;
+  msg.subject = "";
+  msg.charset = "UTF-8";
+  msg.mimeType = "text/plain";
+  msg.priority = "normal";
+  msg.size = static_cast<double>(rawHeaders.size() + rawBody.size());
+  msg.messageId = "";
+  msg.inReplyTo = "";
+  msg.references = "";
+  msg.receivedDate = "";
+  msg.isEncrypted = false;
+
+  std::string textBody, htmlBody;
+  std::vector<AttachmentInfo> attachments;
+  std::string contentType = "text/plain";
+
+  std::istringstream headerStream(rawHeaders);
+  std::string line;
+  std::string currentHeader;
+  std::string currentValue;
+
+  auto flushHeader = [&]() {
+    if (currentHeader.empty()) return;
+    std::string headerName = toUpper(trim(currentHeader));
+    std::string headerValue = decodeMimeHeader(trim(currentValue));
+
+    if (headerName == "SUBJECT") {
+      msg.subject = headerValue;
+    } else if (headerName == "FROM") {
+      std::regex fromRegex(R"x((?:"?([^"]*)"?\s*<([^>]+)>)|(.+))x");
+      std::smatch m;
+      if (std::regex_match(headerValue, m, fromRegex)) {
+        EmailAddress addr;
+        if (m[1].matched) {
+          addr.name = m[1];
+          addr.email = m[2];
+        } else {
+          addr.email = headerValue;
+        }
+        msg.from = addr;
+      } else {
+        EmailAddress addr;
+        addr.email = headerValue;
+        msg.from = addr;
+      }
+    } else if (headerName == "TO") {
+      std::regex addrRegex(R"x((?:"?([^"]*)"?\s*<([^>]+)>)|([^,]+))x");
+      auto begin = std::sregex_iterator(headerValue.begin(), headerValue.end(), addrRegex);
+      auto end = std::sregex_iterator();
+      for (auto it = begin; it != end; ++it) {
+        EmailAddress addr;
+        if ((*it)[1].matched) {
+          addr.name = (*it)[1];
+          addr.email = (*it)[2];
+        } else {
+          addr.email = trim((*it)[0]);
+        }
+        msg.to.push_back(addr);
+      }
+    } else if (headerName == "CC") {
+      std::regex addrRegex(R"x((?:"?([^"]*)"?\s*<([^>]+)>)|([^,]+))x");
+      auto begin = std::sregex_iterator(headerValue.begin(), headerValue.end(), addrRegex);
+      auto end = std::sregex_iterator();
+      for (auto it = begin; it != end; ++it) {
+        EmailAddress addr;
+        if ((*it)[1].matched) {
+          addr.name = (*it)[1];
+          addr.email = (*it)[2];
+        } else {
+          addr.email = trim((*it)[0]);
+        }
+        msg.cc.push_back(addr);
+      }
+    } else if (headerName == "BCC") {
+      std::regex addrRegex(R"x((?:"?([^"]*)"?\s*<([^>]+)>)|([^,]+))x");
+      auto begin = std::sregex_iterator(headerValue.begin(), headerValue.end(), addrRegex);
+      auto end = std::sregex_iterator();
+      for (auto it = begin; it != end; ++it) {
+        EmailAddress addr;
+        if ((*it)[1].matched) {
+          addr.name = (*it)[1];
+          addr.email = (*it)[2];
+        } else {
+          addr.email = trim((*it)[0]);
+        }
+        msg.bcc.push_back(addr);
+      }
+    } else if (headerName == "REPLY-TO" || headerName == "REPLYTO") {
+      EmailAddress addr;
+      std::regex addrRegex(R"x((?:"?([^"]*)"?\s*<([^>]+)>)|([^,]+))x");
+      std::smatch m;
+      if (std::regex_match(headerValue, m, addrRegex)) {
+        if (m[1].matched) {
+          addr.name = m[1];
+          addr.email = m[2];
+        } else {
+          addr.email = trim(m[0]);
+        }
+      }
+      msg.replyTo.push_back(addr);
+    } else if (headerName == "DATE") {
+      msg.date = headerValue;
+    } else if (headerName == "MESSAGE-ID" || headerName == "MESSAGEID") {
+      msg.messageId = headerValue;
+    } else if (headerName == "IN-REPLY-TO") {
+      msg.inReplyTo = headerValue;
+    } else if (headerName == "REFERENCES") {
+      msg.references = headerValue;
+    } else if (headerName == "CONTENT-TYPE") {
+      contentType = headerValue;
+      msg.mimeType = headerValue;
+    } else if (headerName == "CONTENT-TRANSFER-ENCODING") {
+      // Handle transfer encoding
+    } else if (headerName == "PRIORITY" || headerName == "X-PRIORITY") {
+      if (headerValue.find("1") != std::string::npos || headerValue.find("2") != std::string::npos ||
+          toUpper(headerValue).find("HIGH") != std::string::npos || toUpper(headerValue).find("URGENT") != std::string::npos) {
+        msg.priority = "high";
+      } else if (headerValue.find("4") != std::string::npos || headerValue.find("5") != std::string::npos ||
+                 toUpper(headerValue).find("LOW") != std::string::npos || toUpper(headerValue).find("NON-URGENT") != std::string::npos) {
+        msg.priority = "low";
+      }
+    } else if (headerName.find("X-") == 0) {
+      msg.headers[headerName] = headerValue;
+    } else {
+      msg.headers[headerName] = headerValue;
+    }
+  };
+
+  // Parse headers line by line, handling folded headers
+  while (std::getline(headerStream, line)) {
+    if (line.empty() || line == "\r") break;
+    if (!line.empty() && (line[0] == ' ' || line[0] == '\t')) {
+      currentValue += " " + trim(line);
+    } else {
+      if (!currentHeader.empty()) flushHeader();
+      size_t colonPos = line.find(':');
+      if (colonPos != std::string::npos) {
+        currentHeader = line.substr(0, colonPos);
+        currentValue = line.substr(colonPos + 1);
+      }
+    }
+  }
+  if (!currentHeader.empty()) flushHeader();
+
+  std::string bodyContent = rawBody;
+  parseMimeParts(contentType, bodyContent, textBody, htmlBody, attachments);
+
+  EmailBody emailBody;
+  emailBody.text = textBody;
+  emailBody.html = htmlBody;
+  msg.body = emailBody;
+  msg.attachments = attachments;
+
+  return msg;
+}
+
+// ═══════════════════════════════════════════════════════════
+//  IMAP Client Implementation
+// ═══════════════════════════════════════════════════════════
+
+ImapClient::ImapClient()
+  : m_socket(std::make_unique<TlsSocket>())
+{
+  m_state.connected = false;
+  m_state.selected = false;
+  m_state.tagCounter = 0;
+  m_state.tagPrefix = "A";
+}
+
+ImapClient::~ImapClient() {
+  disconnect();
+}
+
+std::string ImapClient::nextTag() {
+  m_state.tagCounter++;
+  return m_state.tagPrefix + std::to_string(m_state.tagCounter);
+}
+
+bool ImapClient::sendRaw(const std::string& data) {
+  return m_socket->send(data);
+}
+
+std::string ImapClient::receiveLine() {
+  return m_socket->receiveLine(30000);
+}
+
+std::string ImapClient::receiveUntil(const std::string& delimiter) {
+  std::string result;
+  while (true) {
+    std::string line = receiveLine();
+    if (line.empty()) break;
+    result += line + "\r\n";
+    if (line == delimiter) break;
+  }
+  return result;
+}
+
+bool ImapClient::waitForTaggedResponse(const std::string& tag, std::string& response, std::string& error) {
+  while (true) {
+    std::string line = receiveLine();
+    if (line.empty()) {
+      error = "Connection closed by server";
+      return false;
+    }
+
+    if (line.size() > 0 && line[0] == '*') {
+      // 检测服务器主动关闭（* BYE），匹配 Android 行为
+      if (line.find("* BYE") == 0 || line.find("*bye") == 0) {
+        m_state.selected = false;
+        m_state.connected = false;
+        error = "Server closed connection";
+        return false;
+      }
+      continue;
+    }
+
+    if (line.find(tag) == 0) {
+      response = line;
+      std::string rest = line.substr(tag.size() + 1);
+      if (rest.find("OK") == 0) {
+        return true;
+      } else if (rest.find("NO") == 0) {
+        error = rest.substr(3);
+        return false;
+      } else if (rest.find("BAD") == 0) {
+        error = rest.substr(4);
+        return false;
+      } else {
+        error = "Unexpected response: " + line;
+        return false;
+      }
+    }
+  }
+}
+
+bool ImapClient::waitForTaggedResponses(const std::string& tag, std::vector<std::string>& responses, std::string& error) {
+  while (true) {
+    std::string line = receiveLine();
+    if (line.empty()) {
+      error = "Connection closed by server";
+      return false;
+    }
+
+    // 检测服务器主动关闭（* BYE），匹配 Android 行为
+    if (line.find("* BYE") == 0 || line.find("*bye") == 0) {
+      m_state.selected = false;
+      m_state.connected = false;
+      error = "Server closed connection";
+      return false;
+    }
+
+    if (line.find(tag) == 0) {
+      std::string rest = line.substr(tag.size() + 1);
+      if (rest.find("OK") == 0) {
+        return true;
+      } else {
+        error = rest;
+        return false;
+      }
+    }
+
+    responses.push_back(line);
+  }
+}
+
+bool ImapClient::sendCommand(const std::string& command, std::string& response, std::string& error) {
+  std::string tag = nextTag();
+  std::string cmd = tag + " " + command + "\r\n";
+  if (!m_socket->send(cmd)) {
+    error = "Failed to send command";
+    return false;
+  }
+  return waitForTaggedResponse(tag, response, error);
+}
+
+bool ImapClient::sendCommandMulti(const std::string& command, std::vector<std::string>& responses, std::string& error) {
+  std::string tag = nextTag();
+  std::string cmd = tag + " " + command + "\r\n";
+  if (!m_socket->send(cmd)) {
+    error = "Failed to send command";
+    return false;
+  }
+  return waitForTaggedResponses(tag, responses, error);
+}
+
+bool ImapClient::connect(const ConnectionConfig& config, std::string& error) {
+  if (!m_socket->connect(config.host, static_cast<int>(config.port),
+                          static_cast<int>(config.timeout), config.checkCertificate)) {
+    error = "Failed to connect to " + config.host + ":" + std::to_string(static_cast<int>(config.port));
+    return false;
+  }
+
+  std::string greeting = receiveLine();
+  if (greeting.empty()) {
+    error = "No greeting from server";
+    disconnect();
+    return false;
+  }
+
+  // If StartTLS is needed but we connected without TLS
+  if (!config.tls && config.port != 993) {
+    std::string response;
+    if (sendCommand("STARTTLS", response, error)) {
+      m_socket->disconnect();
+      if (!m_socket->connect(config.host, static_cast<int>(config.port),
+                              static_cast<int>(config.timeout), config.checkCertificate)) {
+        error = "Failed to establish TLS connection";
+        return false;
+      }
+      greeting = receiveLine();
+      if (greeting.empty()) {
+        error = "No greeting after STARTTLS";
+        disconnect();
+        return false;
+      }
+    }
+  }
+
+  // Login
+  bool loginSuccess = false;
+  if (toUpper(config.authType) == "OAUTH2" && config.accessToken.has_value()) {
+    std::string authString = "user=" + config.username + "\x01" +
+                             "auth=Bearer " + config.accessToken.value() + "\x01\x01";
+    std::string encoded = encodeBase64Text(authString);
+    std::string response;
+    if (sendCommand("AUTHENTICATE XOAUTH2 " + encoded, response, error)) {
+      loginSuccess = true;
+    }
+  } else {
+    // Standard LOGIN with quoted strings (RFC 3501)
+    auto escape = [](const std::string& s) -> std::string {
+      std::string result = "\"";
+      for (char c : s) {
+        if (c == '\\' || c == '"') result += '\\';
+        result += c;
+      }
+      result += '"';
+      return result;
+    };
+    std::string response;
+    if (sendCommand("LOGIN " + escape(config.username) + " " + escape(config.password), response, error)) {
+      loginSuccess = true;
+    }
+  }
+
+  if (!loginSuccess) {
+    if (error.empty()) error = "Login failed";
+    disconnect();
+    return false;
+  }
+
+  m_state.connected = true;
+  m_state.config = config;
+
+  // Send ID command (RFC 2971) - many Chinese email servers require this
+  std::string idCmd = "ID (\"name\" \"react-native-email-imap-smtp\""
+                      " \"version\" \"1.0.0\""
+                      " \"vendor\" \"react-native-email-imap-smtp\""
+                      " \"os\" \"Windows\""
+                      " \"os-version\" \"10\")";
+  std::string idResponse;
+  sendCommand(idCmd, idResponse, error); // Ignore failure
+
+  return true;
+}
+
+void ImapClient::disconnect() {
+  if (m_state.connected) {
+    std::string error;
+    sendCommand("LOGOUT", error, error);
+  }
+  m_socket->disconnect();
+  m_state.connected = false;
+  m_state.selected = false;
+  m_state.selectedMailbox.clear();
+}
+
+bool ImapClient::isConnected() const {
+  return m_state.connected && m_socket->isConnected();
+}
+
+// ─── Mailbox operations ─────────────────────────────────────
+
+std::vector<MailboxListItem> ImapClient::listMailboxes(std::string& error) {
+  std::vector<MailboxListItem> result;
+  std::vector<std::string> responses;
+
+  if (!sendCommandMulti("LIST \"\" \"*\"", responses, error)) {
+    return result;
+  }
+
+  std::vector<std::string> subscribed;
+  sendCommandMulti("LSUB \"\" \"*\"", subscribed, error);
+  std::set<std::string> subscribedPaths;
+  for (const auto& line : subscribed) {
+    std::regex pathRegex(R"re(LSUB\s+.*\s+"?([^"]+)"?\s*$)re");
+    std::smatch m;
+    if (std::regex_search(line, m, pathRegex) && m.size() > 1) {
+      subscribedPaths.insert(trim(m[1]));
+    }
+  }
+
+  for (const auto& line : responses) {
+    std::regex listRegex(R"re(\*\s+LIST\s+\(([^)]*)\)\s+"([^"]*)"\s+"?([^"]+)"?")re");
+    std::smatch match;
+    if (std::regex_search(line, match, listRegex) && match.size() > 3) {
+      MailboxListItem item;
+      item.name = decodeImapUtf7(match[3]);
+      item.path = item.name;
+      item.delimiter = decodeImapUtf7(match[2]);
+      if (match[1].matched) {
+        std::string flagsStr = match[1].str();
+        std::istringstream flagStream(flagsStr);
+        std::string flag;
+        while (flagStream >> flag) {
+          item.flags.push_back(flag);
+        }
+      }
+      item.subscribed = subscribedPaths.find(item.path) != subscribedPaths.end();
+      result.push_back(item);
+    }
+  }
+
+  return result;
+}
+
+MailboxInfo ImapClient::selectMailbox(const std::string& mailbox, bool readOnly, std::string& error) {
+  MailboxInfo info;
+  info.name = mailbox;
+  info.path = mailbox;
+
+  std::string cmd = readOnly ? "EXAMINE " : "SELECT ";
+  if (mailbox.find(' ') != std::string::npos || mailbox.find('"') != std::string::npos) {
+    std::string escaped;
+    for (char c : mailbox) {
+      if (c == '\\' || c == '"') escaped += '\\';
+      escaped += c;
+    }
+    cmd += "\"" + escaped + "\"";
+  } else {
+    cmd += mailbox;
+  }
+
+  std::vector<std::string> responses;
+  if (!sendCommandMulti(cmd, responses, error)) {
+    return info;
+  }
+
+  for (const auto& line : responses) {
+    std::regex existsRegex(R"x(\*\s+(\d+)\s+EXISTS)x");
+    std::smatch m;
+    if (std::regex_search(line, m, existsRegex) && m.size() > 1) {
+      info.messageCount = std::stod(m[1]);
+    }
+
+    std::regex recentRegex(R"x(\*\s+(\d+)\s+RECENT)x");
+    if (std::regex_search(line, m, recentRegex) && m.size() > 1) {
+      info.recentCount = std::stod(m[1]);
+    }
+
+    std::regex uidNextRegex(R"x(\[UIDNEXT\s+(\d+)\])x");
+    if (std::regex_search(line, m, uidNextRegex) && m.size() > 1) {
+      info.uidNext = std::stod(m[1]);
+    }
+
+    std::regex uidValRegex(R"x(\[UIDVALIDITY\s+(\d+)\])x");
+    if (std::regex_search(line, m, uidValRegex) && m.size() > 1) {
+      info.uidValidity = std::stod(m[1]);
+    }
+
+    std::regex unseenRegex(R"x(\[UNSEEN\s+(\d+)\])x");
+    if (std::regex_search(line, m, unseenRegex) && m.size() > 1) {
+      info.unseenCount = std::stod(m[1]);
+    }
+
+    std::regex modSeqRegex(R"x(\[HIGHESTMODSEQ\s+(\d+)\])x");
+    if (std::regex_search(line, m, modSeqRegex) && m.size() > 1) {
+      info.highestModSeq = std::stod(m[1]);
+    }
+
+    std::regex permFlagsRegex(R"x(\[PERMANENTFLAGS\s+\(([^)]*)\)\])x");
+    if (std::regex_search(line, m, permFlagsRegex) && m.size() > 1) {
+      std::string flagsStr = m[1];
+      std::istringstream flagStream(flagsStr);
+      std::string flag;
+      while (flagStream >> flag) {
+        info.permanentFlags.push_back(flag);
+      }
+    }
+
+    std::regex flagsRegex(R"x(\[FLAGS\s+\(([^)]*)\)\])x");
+    if (std::regex_search(line, m, flagsRegex) && m.size() > 1) {
+      std::string flagsStr = m[1];
+      std::istringstream flagStream(flagsStr);
+      std::string flag;
+      while (flagStream >> flag) {
+        info.flags.push_back(flag);
+      }
+    }
+  }
+
+  m_state.selected = true;
+  m_state.selectedMailbox = mailbox;
+
+  return info;
+}
+
+MailboxInfo ImapClient::refreshMailbox(std::string& error) {
+  if (!m_state.selected) {
+    error = "No mailbox selected";
+    return MailboxInfo();
+  }
+  std::string response;
+  sendCommand("NOOP", response, error);
+  return selectMailbox(m_state.selectedMailbox, false, error);
+}
+
+std::vector<FolderInfo> ImapClient::fetchFolders(std::string& error) {
+  std::vector<FolderInfo> result;
+  std::vector<std::string> responses;
+
+  if (!sendCommandMulti("LIST \"\" \"*\"", responses, error)) {
+    return result;
+  }
+
+  for (const auto& line : responses) {
+    std::regex listRegex(R"re(\*\s+LIST\s+\(([^)]*)\)\s+"([^"]*)"\s+"?([^"]+)"?")re");
+    std::smatch match;
+    if (std::regex_search(line, match, listRegex) && match.size() > 3) {
+      FolderInfo folder;
+      folder.name = decodeImapUtf7(match[3]);
+      folder.path = folder.name;
+      folder.delimiter = decodeImapUtf7(match[2]);
+      folder.parent = "";
+      folder.subscribed = false;
+      if (match[1].matched) {
+        std::string flagsStr = match[1].str();
+        std::istringstream flagStream(flagsStr);
+        std::string flag;
+        while (flagStream >> flag) {
+          folder.flags.push_back(flag);
+        }
+      }
+      result.push_back(folder);
+    }
+  }
+
+  return result;
+}
+
+bool ImapClient::createFolder(const std::string& folderName, std::string& error) {
+  std::string response;
+  return sendCommand("CREATE \"" + folderName + "\"", response, error);
+}
+
+bool ImapClient::deleteFolder(const std::string& folderName, std::string& error) {
+  std::string response;
+  return sendCommand("DELETE \"" + folderName + "\"", response, error);
+}
+
+bool ImapClient::renameFolder(const std::string& oldName, const std::string& newName, std::string& error) {
+  std::string response;
+  return sendCommand("RENAME \"" + oldName + "\" \"" + newName + "\"", response, error);
+}
+
+bool ImapClient::subscribeFolder(const std::string& folderName, std::string& error) {
+  std::string response;
+  return sendCommand("SUBSCRIBE \"" + folderName + "\"", response, error);
+}
+
+bool ImapClient::unsubscribeFolder(const std::string& folderName, std::string& error) {
+  std::string response;
+  return sendCommand("UNSUBSCRIBE \"" + folderName + "\"", response, error);
+}
+
+// ─── Fetch Emails ───────────────────────────────────────────
+
+std::vector<EmailMessage> ImapClient::fetchEmails(const FetchEmailsOptions& options, std::string& error) {
+  std::vector<EmailMessage> result;
+
+  if (options.mailbox.has_value() && options.mailbox.value() != m_state.selectedMailbox) {
+    selectMailbox(options.mailbox.value(), false, error);
+  }
+
+  if (!m_state.selected) {
+    // 匹配 Android 行为：FolderClosed 时重选邮箱重试一次
+    if (!m_state.selectedMailbox.empty() && (!options.mailbox.has_value() || options.mailbox.value() == m_state.selectedMailbox)) {
+      selectMailbox(m_state.selectedMailbox, false, error);
+      if (m_state.selected) {
+        return fetchEmails(options, error);
+      }
+    }
+    error = "No mailbox selected";
+    return result;
+  }
+
+  // ── 构建 UID 列表（支持 since/before 日期过滤，匹配 Android 行为）──
+  std::vector<long> targetUids;
+  bool hasDateFilter = options.since.has_value() || options.before.has_value();
+
+  // 先通过 UID SEARCH 获取匹配日期范围的 UID 列表
+  if (hasDateFilter) {
+    std::string searchCmd = "UID SEARCH ALL";
+    if (options.since.has_value())  searchCmd += " SINCE " + options.since.value();
+    if (options.before.has_value()) searchCmd += " BEFORE " + options.before.value();
+
+    std::vector<std::string> searchResp;
+    if (!sendCommandMulti(searchCmd, searchResp, error)) {
+      // 匹配 Android 行为：FolderClosed 时重选邮箱重试一次
+      if (!m_state.selected && !m_state.selectedMailbox.empty()) {
+        selectMailbox(m_state.selectedMailbox, false, error);
+        if (m_state.selected) return fetchEmails(options, error);
+      }
+      return result;
+    }
+    for (const auto& line : searchResp) {
+      std::regex uidRegex(R"x(\*\s+SEARCH\s+(.+))x");
+      std::smatch m;
+      if (std::regex_match(line, m, uidRegex) && m.size() > 1) {
+        std::istringstream uidStream(m[1].str());
+        long uid;
+        while (uidStream >> uid) {
+          targetUids.push_back(uid);
+        }
+      }
+    }
+  }
+
+  // 根据范围/分页模式筛选 UID
+  if (options.from.has_value() && options.to.has_value() && options.rangeType.has_value() &&
+      toUpper(options.rangeType.value()) == "UID") {
+    // UID 范围模式
+    long fromUid = static_cast<long>(options.from.value());
+    long toUid = static_cast<long>(options.to.value());
+    if (!hasDateFilter) {
+      for (long u = fromUid; u <= toUid; u++) targetUids.push_back(u);
+    } else {
+      // 与日期过滤取交集
+      std::vector<long> filtered;
+      for (long u : targetUids) {
+        if (u >= fromUid && u <= toUid) filtered.push_back(u);
+      }
+      targetUids = filtered;
+    }
+  } else if (options.from.has_value() && options.to.has_value()) {
+    // 序列号范围模式：与日期过滤组合
+    std::string searchCmd = "UID SEARCH " +
+      std::to_string(static_cast<long>(options.from.value())) + ":" +
+      std::to_string(static_cast<long>(options.to.value()));
+    if (options.since.has_value())  searchCmd += " SINCE " + options.since.value();
+    if (options.before.has_value()) searchCmd += " BEFORE " + options.before.value();
+    std::vector<std::string> searchResp;
+    if (!sendCommandMulti(searchCmd, searchResp, error)) {
+      // 匹配 Android 行为：FolderClosed 时重选邮箱重试一次
+      if (!m_state.selected && !m_state.selectedMailbox.empty()) {
+        selectMailbox(m_state.selectedMailbox, false, error);
+        if (m_state.selected) return fetchEmails(options, error);
+      }
+      return result;
+    }
+    for (const auto& line : searchResp) {
+      std::regex uidRegex(R"x(\*\s+SEARCH\s+(.+))x");
+      std::smatch m;
+      if (std::regex_match(line, m, uidRegex) && m.size() > 1) {
+        std::istringstream uidStream(m[1].str());
+        long uid;
+        while (uidStream >> uid) {
+          targetUids.push_back(uid);
+        }
+      }
+    }
+  } else if (options.page.has_value() || !hasDateFilter) {
+    // 分页模式或默认模式
+    if (!hasDateFilter) {
+      std::vector<std::string> searchResp;
+      sendCommandMulti("UID SEARCH ALL", searchResp, error);
+      for (const auto& line : searchResp) {
+        std::regex uidRegex(R"x(\*\s+SEARCH\s+(.+))x");
+        std::smatch m;
+        if (std::regex_match(line, m, uidRegex) && m.size() > 1) {
+          std::istringstream uidStream(m[1].str());
+          long uid;
+          while (uidStream >> uid) {
+            targetUids.push_back(uid);
+          }
+        }
+      }
+    }
+  }
+
+  // 按 UID 降序排列（最新的在前）
+  std::sort(targetUids.begin(), targetUids.end(), std::greater<long>());
+
+  // 分页截取
+  if (options.page.has_value()) {
+    int page = static_cast<int>(options.page.value());
+    int pageSize = static_cast<int>(options.pageSize.value_or(20));
+    int startIdx = (page - 1) * pageSize;
+    int endIdx = std::min(startIdx + pageSize, static_cast<int>(targetUids.size()));
+    if (startIdx < static_cast<int>(targetUids.size())) {
+      targetUids = std::vector<long>(targetUids.begin() + startIdx, targetUids.begin() + endIdx);
+    } else {
+      return result; // 页码超出范围
+    }
+  } else if (!hasDateFilter && !options.from.has_value() && !options.to.has_value()) {
+    // 默认只取最近 20 封（匹配 Android 行为）
+    if (targetUids.size() > 20) targetUids.resize(20);
+  }
+
+  if (targetUids.empty()) return result;
+
+  // 逐条获取完整邮件内容（匹配 Android 行为，与 searchEmails 同一模式）
+  for (long uid : targetUids) {
+    std::string fetchError;
+    EmailMessage* msg = fetchEmailByUID(static_cast<double>(uid), fetchError);
+    if (msg) {
+      result.push_back(*msg);
+      delete msg;
+    }
+  }
+
+  // 匹配 Android 行为：FolderClosed 时重选邮箱重试一次
+  if (result.empty() && !m_state.selected && !m_state.selectedMailbox.empty()) {
+    selectMailbox(m_state.selectedMailbox, false, error);
+    if (m_state.selected) {
+      return fetchEmails(options, error);
+    }
+  }
+
+  return result;
+}
+
+EmailMessage* ImapClient::fetchEmailByUID(double uid, std::string& error) {
+  if (!m_state.selected) {
+    error = "No mailbox selected";
+    return nullptr;
+  }
+
+  std::vector<std::string> responses;
+  std::string cmd = "UID FETCH " + std::to_string(static_cast<long>(uid)) +
+    " (FLAGS INTERNALDATE BODY.PEEK[HEADER] BODY.PEEK[TEXT])";
+
+  if (!sendCommandMulti(cmd, responses, error)) {
+    return nullptr;
+  }
+
+  std::string headers, body;
+  bool inHeader = false, inText = false;
+
+  for (const auto& line : responses) {
+    if (line.find("BODY[HEADER]") != std::string::npos) {
+      inHeader = true; inText = false; continue;
+    }
+    if (line.find("BODY[TEXT]") != std::string::npos) {
+      inHeader = false; inText = true; continue;
+    }
+    if (line == ")") {
+      inHeader = false; inText = false; continue;
+    }
+    if (inHeader) headers += line + "\r\n";
+    if (inText) body += line + "\r\n";
+  }
+
+  if (headers.empty() && body.empty()) return nullptr;
+
+  EmailMessage msg = parseMessage(headers, body, uid, 0);
+  return new EmailMessage(std::move(msg));
+}
+
+// ─── Search ─────────────────────────────────────────────────
+
+std::vector<EmailMessage> ImapClient::searchEmails(const SearchCriteria& criteria, std::string& error) {
+  std::vector<EmailMessage> result;
+
+  if (criteria.mailbox.has_value() && criteria.mailbox.value() != m_state.selectedMailbox) {
+    selectMailbox(criteria.mailbox.value(), false, error);
+  }
+
+  if (!m_state.selected) {
+    error = "No mailbox selected";
+    return result;
+  }
+
+  if (criteria.uids.has_value() && !criteria.uids.value().empty()) {
+    for (double uid : criteria.uids.value()) {
+      EmailMessage* msg = fetchEmailByUID(uid, error);
+      if (msg) {
+        result.push_back(*msg);
+        delete msg;
+      }
+    }
+    return result;
+  }
+
+  std::string searchCmd = "UID SEARCH ALL";
+
+  if (criteria.subject.has_value())    searchCmd += " SUBJECT \"" + criteria.subject.value() + "\"";
+  if (criteria.from.has_value())       searchCmd += " FROM \"" + criteria.from.value() + "\"";
+  if (criteria.to.has_value())         searchCmd += " TO \"" + criteria.to.value() + "\"";
+  if (criteria.body.has_value())       searchCmd += " BODY \"" + criteria.body.value() + "\"";
+  if (criteria.text.has_value())       searchCmd += " TEXT \"" + criteria.text.value() + "\"";
+  if (criteria.since.has_value())      searchCmd += " SINCE " + criteria.since.value();
+  if (criteria.before.has_value())     searchCmd += " BEFORE " + criteria.before.value();
+  if (criteria.on.has_value())         searchCmd += " ON " + criteria.on.value();
+  if (criteria.sentSince.has_value())  searchCmd += " SENTSINCE " + criteria.sentSince.value();
+  if (criteria.sentBefore.has_value()) searchCmd += " SENTBEFORE " + criteria.sentBefore.value();
+  if (criteria.flagged)                searchCmd += " FLAGGED";
+  if (criteria.seen)                   searchCmd += " SEEN";
+  if (criteria.answered)               searchCmd += " ANSWERED";
+  if (criteria.draft)                  searchCmd += " DRAFT";
+  if (criteria.deleted)                searchCmd += " DELETED";
+  if (criteria.header.has_value())     searchCmd += " HEADER " + criteria.header.value().key + " \"" + criteria.header.value().value + "\"";
+  if (criteria.larger.has_value())     searchCmd += " LARGER " + std::to_string(static_cast<long>(criteria.larger.value()));
+  if (criteria.smaller.has_value())    searchCmd += " SMALLER " + std::to_string(static_cast<long>(criteria.smaller.value()));
+  if (criteria.sortOrder.has_value() && toUpper(criteria.sortOrder.value()) == "ASC") {
+    searchCmd += " SORT (DATE)";
+  }
+
+  std::vector<std::string> responses;
+  if (!sendCommandMulti(searchCmd, responses, error)) {
+    return result;
+  }
+
+  std::vector<long> uids;
+  for (const auto& line : responses) {
+    std::regex uidRegex(R"x(\*\s+SEARCH\s+(.+))x");
+    std::smatch m;
+    if (std::regex_match(line, m, uidRegex) && m.size() > 1) {
+      std::istringstream uidStream(m[1].str());
+      long uid;
+      while (uidStream >> uid) {
+        uids.push_back(uid);
+      }
+    }
+  }
+
+  if (!criteria.sortOrder.has_value() || toUpper(criteria.sortOrder.value()) != "ASC") {
+    std::sort(uids.begin(), uids.end(), std::greater<long>());
+  }
+
+  if (criteria.limit.has_value() && criteria.limit.value() > 0) {
+    size_t limit = static_cast<size_t>(criteria.limit.value());
+    if (uids.size() > limit) uids.resize(limit);
+  }
+
+  for (long uid : uids) {
+    EmailMessage* msg = fetchEmailByUID(static_cast<double>(uid), error);
+    if (msg) {
+      if (criteria.hasAttachment) {
+        std::string ct = toUpper(msg->mimeType);
+        if (ct.find("MULTIPART/MIXED") == std::string::npos &&
+            ct.find("MULTIPART/RELATED") == std::string::npos &&
+            ct.find("MULTIPART/SIGNED") == std::string::npos) {
+          delete msg;
+          continue;
+        }
+      }
+      result.push_back(*msg);
+      delete msg;
+    }
+  }
+
+  return result;
+}
+
+// ─── Flags ──────────────────────────────────────────────────
+
+// 匹配 Android 行为：逐条处理，部分失败不阻断后续
+bool ImapClient::markAsRead(const std::vector<double>& uids, bool silent, std::string& error) {
+  if (!m_state.selected) { error = "No mailbox selected"; return false; }
+
+  for (double uid : uids) {
+    std::string response, cmdError;
+    sendCommand("UID STORE " + std::to_string(static_cast<long>(uid)) + " +FLAGS.SILENT (\\Seen)", response, cmdError);
+  }
+  return true;
+}
+
+bool ImapClient::markAsFlagged(const std::vector<double>& uids, bool flagged, std::string& error) {
+  if (!m_state.selected) { error = "No mailbox selected"; return false; }
+
+  std::string cmd = flagged ? "+FLAGS.SILENT (\\Flagged)" : "-FLAGS.SILENT (\\Flagged)";
+  for (double uid : uids) {
+    std::string response, cmdError;
+    sendCommand("UID STORE " + std::to_string(static_cast<long>(uid)) + " " + cmd, response, cmdError);
+  }
+  return true;
+}
+
+// ─── Move / Copy / Delete ───────────────────────────────────
+
+bool ImapClient::moveEmails(const std::vector<double>& uids, const std::string& destinationMailbox, std::string& error) {
+  if (!m_state.selected) { error = "No mailbox selected"; return false; }
+
+  std::string uidList;
+  for (double uid : uids) {
+    if (!uidList.empty()) uidList += ",";
+    uidList += std::to_string(static_cast<long>(uid));
+  }
+
+  std::string response;
+  if (sendCommand("UID MOVE " + uidList + " \"" + destinationMailbox + "\"", response, error)) {
+    return true;
+  }
+
+  error = "";
+  if (!sendCommand("UID COPY " + uidList + " \"" + destinationMailbox + "\"", response, error)) {
+    return false;
+  }
+  error = "";
+  if (!sendCommand("UID STORE " + uidList + " +FLAGS.SILENT (\\Deleted)", response, error)) {
+    return false;
+  }
+  return expunge(error);
+}
+
+bool ImapClient::copyEmails(const std::vector<double>& uids, const std::string& destinationMailbox, std::string& error) {
+  if (!m_state.selected) { error = "No mailbox selected"; return false; }
+
+  std::string uidList;
+  for (double uid : uids) {
+    if (!uidList.empty()) uidList += ",";
+    uidList += std::to_string(static_cast<long>(uid));
+  }
+  std::string response;
+  return sendCommand("UID COPY " + uidList + " \"" + destinationMailbox + "\"", response, error);
+}
+
+DeleteResult ImapClient::deleteEmails(const std::vector<double>& uids, std::string& error) {
+  DeleteResult result;
+
+  if (!m_state.selected) { error = "No mailbox selected"; result.error = error; return result; }
+
+  // 逐条 UID 处理，匹配 Android 行为
+  for (double uid : uids) {
+    bool retried = false;
+    while (true) {
+      std::string cmd = "UID STORE " + std::to_string(static_cast<long>(uid)) + " +FLAGS.SILENT (\\Deleted)";
+      std::string response;
+      if (sendCommand(cmd, response, error)) {
+        result.success.push_back(uid);
+        break;
+      }
+      // 若文件夹被服务器关闭（类似 Android 的 FolderClosedException），重选后重试一次
+      if (!retried && !m_state.selected) {
+        retried = true;
+        // 重新选择邮箱（匹配 Android 的 ensureFolderOpen）
+        if (!m_state.selectedMailbox.empty()) {
+          selectMailbox(m_state.selectedMailbox, false, error);
+        }
+        continue;
+      }
+      result.failed.push_back(uid);
+      break;
+    }
+  }
+
+  // 有成功删除的邮件才执行 EXPUNGE
+  if (!result.success.empty()) {
+    std::string expungeError;
+    expunge(expungeError);
+  }
+
+  // 有失败时设置错误信息，匹配 Android 行为
+  if (!result.failed.empty()) {
+    result.error = std::to_string(result.failed.size()) + " messages failed";
+    if (!error.empty()) result.error = result.error.value() + ": " + error;
+  }
+
+  return result;
+}
+
+bool ImapClient::expunge(std::string& error) {
+  if (!m_state.selected) return true;
+  std::string response;
+  return sendCommand("EXPUNGE", response, error);
+}
+
+// ─── Attachments ────────────────────────────────────────────
+
+AttachmentInfo* ImapClient::fetchAttachment(double uid, const std::string& partId, std::string& error) {
+  std::vector<std::string> responses;
+  std::string cmd = "UID FETCH " + std::to_string(static_cast<long>(uid)) +
+    " (BODY.PEEK[" + partId + "])";
+
+  if (!sendCommandMulti(cmd, responses, error)) return nullptr;
+
+  std::string bodyContent;
+  bool inPart = false;
+  for (const auto& line : responses) {
+    if (line.find("BODY[" + partId + "]") != std::string::npos) { inPart = true; continue; }
+    if (line == ")") { inPart = false; continue; }
+    if (inPart) bodyContent += line + "\r\n";
+  }
+
+  if (bodyContent.empty()) return nullptr;
+
+  AttachmentInfo* info = new AttachmentInfo();
+  info->filename = "attachment_" + partId;
+  info->mimeType = "application/octet-stream";
+  info->partId = partId;
+  info->size = static_cast<double>(bodyContent.size());
+  info->data.assign(bodyContent.begin(), bodyContent.end()); // ArrayBuffer::copy → vector<uint8_t>
+  info->contentId = std::nullopt;
+  info->isInline = false;
+  info->charset = std::nullopt;
+  info->contentDisposition = "attachment";
+  info->localPath = std::nullopt;
+
+  return info;
+}
+
+std::vector<AttachmentInfo> ImapClient::fetchAllAttachments(double uid, std::string& error) {
+  std::vector<AttachmentInfo> result;
+
+  std::vector<std::string> responses;
+  std::string cmd = "UID FETCH " + std::to_string(static_cast<long>(uid)) + " (BODYSTRUCTURE)";
+  if (!sendCommandMulti(cmd, responses, error)) return result;
+
+  cmd = "UID FETCH " + std::to_string(static_cast<long>(uid)) + " (BODY.PEEK[]<0.10485760>)";
+  responses.clear();
+  if (!sendCommandMulti(cmd, responses, error)) return result;
+
+  std::string fullContent;
+  bool inBody = false;
+  for (const auto& line : responses) {
+    if (line.find("BODY[]") != std::string::npos) { inBody = true; continue; }
+    if (line == ")") { inBody = false; continue; }
+    if (inBody) fullContent += line + "\r\n";
+  }
+
+  if (fullContent.empty()) return result;
+
+  std::regex attachmentRegex(R"re(Content-Disposition:\s*attachment[^;]*;\s*filename\s*=\s*"?([^";\r\n]+)"?")re",
+                             std::regex::icase);
+  auto begin = std::sregex_iterator(fullContent.begin(), fullContent.end(), attachmentRegex);
+  auto end = std::sregex_iterator();
+
+  for (auto it = begin; it != end; ++it) {
+    AttachmentInfo att;
+    att.filename = (*it)[1];
+    att.mimeType = "application/octet-stream";
+    att.partId = "attachment_" + std::to_string(result.size());
+    att.size = 0;
+    att.data = std::vector<uint8_t>(); // ArrayBuffer::copy(nullptr, 0) → empty vector
+    att.contentId = std::nullopt;
+    att.isInline = false;
+    att.charset = std::nullopt;
+    att.contentDisposition = "attachment";
+    att.localPath = std::nullopt;
+    result.push_back(att);
+  }
+
+  return result;
+}
+
+// ─── IDLE ───────────────────────────────────────────────────
+
+bool ImapClient::idle(const std::function<void(const IdleNotification&)>& callback, std::string& error) {
+  if (!m_state.selected) { error = "No mailbox selected"; return false; }
+
+  std::string tag = nextTag();
+  std::string cmd = tag + " IDLE\r\n";
+  if (!m_socket->send(cmd)) { error = "Failed to send IDLE command"; return false; }
+
+  std::string response = receiveLine();
+  if (response.empty() || response[0] != '+') { error = "IDLE not accepted by server"; return false; }
+
+  return true;
+}
+
+bool ImapClient::stopIdle(std::string& error) {
+  if (!m_socket->send("DONE\r\n")) { error = "Failed to send DONE"; return false; }
+
+  std::string response;
+  return waitForTaggedResponse(m_state.tagPrefix + std::to_string(m_state.tagCounter), response, error);
+}
+
+// ─── Quota ──────────────────────────────────────────────────
+
+QuotaInfo ImapClient::getQuota(const std::optional<std::string>& root, std::string& error) {
+  QuotaInfo info;
+  info.storageUsed = 0;
+  info.storageLimit = -1;
+  info.storageUnit = "KB";
+  info.root = root.value_or("");
+
+  std::string quotaRoot = root.value_or("");
+  if (quotaRoot.empty()) quotaRoot = "\"\"";
+  else quotaRoot = "\"" + quotaRoot + "\"";
+
+  std::vector<std::string> responses;
+  sendCommandMulti("GETQUOTA " + quotaRoot, responses, error);
+
+  for (const auto& line : responses) {
+    std::regex quotaRegex(R"x(STORAGE\s+(\d+)\s+(\d+))x");
+    std::smatch m;
+    if (std::regex_search(line, m, quotaRegex) && m.size() > 2) {
+      info.storageUsed = std::stod(m[1]);
+      info.storageLimit = std::stod(m[2]);
+    }
+  }
+
+  return info;
+}
+
+// ─── Append ─────────────────────────────────────────────────
+
+AppendResult ImapClient::appendMessage(const std::string& mailbox,
+                                        const std::vector<uint8_t>& rawMimeData,
+                                        const std::optional<std::vector<std::string>>& flags,
+                                        std::string& error) {
+  AppendResult result;
+  result.uid = -1;
+  result.uidValidity = 0;
+
+  std::string mimeData(rawMimeData.begin(), rawMimeData.end());
+
+  std::string flagStr;
+  if (flags.has_value() && !flags.value().empty()) {
+    flagStr = " (";
+    for (const auto& flag : flags.value()) {
+      std::string upper = toUpper(flag);
+      if (upper == "SEEN")      flagStr += "\\Seen ";
+      else if (upper == "FLAGGED")  flagStr += "\\Flagged ";
+      else if (upper == "DELETED")  flagStr += "\\Deleted ";
+      else if (upper == "DRAFT")    flagStr += "\\Draft ";
+      else if (upper == "ANSWERED") flagStr += "\\Answered ";
+      else flagStr += flag + " ";
+    }
+    flagStr.pop_back();
+    flagStr += ")";
+  }
+
+  std::string tag = nextTag();
+  std::string cmd = tag + " APPEND \"" + mailbox + "\"" + flagStr + " {" +
+                    std::to_string(mimeData.size()) + "}\r\n";
+
+  if (!m_socket->send(cmd)) { error = "Failed to send APPEND command"; return result; }
+
+  std::string response = receiveLine();
+  if (response.empty() || response[0] != '+') { error = "APPEND not accepted"; return result; }
+
+  if (!m_socket->send(mimeData + "\r\n")) { error = "Failed to send MIME data"; return result; }
+
+  if (!waitForTaggedResponse(tag, response, error)) return result;
+
+  std::regex uidRegex(R"x(\[APPENDUID\s+(\d+)\s+(\d+)\])x");
+  std::smatch m;
+  if (std::regex_search(response, m, uidRegex) && m.size() > 2) {
+    result.uidValidity = std::stod(m[1]);
+    result.uid = std::stod(m[2]);
+  }
+
+  result.date = currentTimestamp();
+  return result;
+}
+
+} // namespace emailimap