react-native-email-imap-smtp 0.1.0

package/android/src/main/java/com/margelo/nitro/emailimapsmtp/EmailImapSmtp.kt

@@ -0,0 +1,1533 @@
+package com.margelo.nitro.emailimapsmtp
+
+import android.util.Log
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.ArrayBuffer
+import com.margelo.nitro.core.Promise
+import com.sun.mail.imap.IMAPFolder
+import com.sun.mail.imap.IMAPStore
+import com.sun.mail.smtp.SMTPTransport
+import jakarta.mail.*
+import jakarta.mail.internet.*
+import jakarta.mail.search.*
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.io.FileOutputStream
+import java.security.cert.X509Certificate
+import java.time.ZoneId
+import java.time.ZonedDateTime
+import java.time.format.DateTimeFormatter
+import java.util.*
+import java.util.concurrent.Executors
+import javax.net.ssl.SSLContext
+import javax.net.ssl.SSLSocketFactory
+import javax.net.ssl.X509TrustManager
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.asCoroutineDispatcher
+
+private const val TAG = "EmailImapSmtp"
+
+/** 单个附件最大 10MB，超过则截断 */
+private const val MAX_ATTACHMENT_SIZE = 10 * 1024 * 1024L
+
+/** 单次 FETCH 获取邮件最大数量 */
+private const val MAX_FETCH_COUNT = 200
+
+/** 附件缓存目录（系统临时目录） */
+private val ATTACHMENT_CACHE_DIR: File by lazy {
+  File(System.getProperty("java.io.tmpdir"), "email_attachments").also { it.mkdirs() }
+}
+
+@DoNotStrip
+class EmailImapSmtp : HybridEmailImapSmtpSpec() {
+  private var imapStore: IMAPStore? = null
+  private var imapFolder: IMAPFolder? = null
+  private var smtpTransport: SMTPTransport? = null
+  private var smtpSessionCache: Session? = null
+  private var smtpConfig: SmtpConnectionConfig? = null
+  private var selectedMailbox: String? = null
+  private var imapConfig: ConnectionConfig? = null
+
+  @Volatile
+  private var isIdling = false
+
+  // ─── helpers ──────────────────────────────────────────────
+
+  /** 创建信任所有证书的 SocketFactory（用于 checkCertificate=false 或 163邮箱等特殊服务器） */
+  private val trustAllSocketFactory: SSLSocketFactory by lazy {
+    val ctx = SSLContext.getInstance("TLS")
+    ctx.init(null, arrayOf(object : X509TrustManager {
+      override fun checkClientTrusted(p0: Array<X509Certificate?>, p1: String?) {}
+      override fun checkServerTrusted(p0: Array<X509Certificate?>, p1: String?) {}
+      override fun getAcceptedIssuers(): Array<X509Certificate> = emptyArray()
+    }), null)
+    ctx.socketFactory
+  }
+
+  private fun imapSession(config: ConnectionConfig): Session {
+    val props = Properties().apply {
+      put("mail.imap.host", config.host)
+      put("mail.imap.port", config.port.toInt().toString())
+      put("mail.imap.connectiontimeout", config.timeout.toInt().toString())
+      put("mail.imap.timeout", config.timeout.toInt().toString())
+      put("mail.imap.writetimeout", config.timeout.toInt().toString())
+      put("mail.store.protocol", "imap")
+      put("mail.imap.fetchsize", "1048576")
+      put("mail.imap.partialfetch", "true")
+      // 增加连接保活相关设置
+      // 注意: 不设置 separatestoreconnection，让 store 和 folder 共用同一连接
+      // 这样 connect 阶段发送的 ID 命令才能在 folder.open() 的 SELECT 时生效
+      put("mail.imap.folder.noselect", "false")
+      put("mail.imap.connectionpooltimeout", config.timeout.toInt().toString())
+
+      // ── SSL/TLS 配置 ──────────────────────────────────────
+      // TLS 启用：对于 993 端口必须开启
+      if (config.tls) {
+        put("mail.imap.ssl.enable", "true")
+      }
+
+      // 若 checkCertificate=false，使用信任所有证书的 SocketFactory
+      // 163/188 等国内邮箱的自签名或非标准证书需要此设置
+      if (!config.checkCertificate) {
+        put("mail.imap.ssl.socketFactory", trustAllSocketFactory)
+        put("mail.imap.ssl.socketFactory.fallback", "false")
+      }
+
+      if (config.debug) put("mail.debug", "true")
+    }
+    return Session.getInstance(props)
+  }
+
+  private fun smtpSession(config: SmtpConnectionConfig): Session {
+    val props = Properties().apply {
+      put("mail.smtp.host", config.host)
+      put("mail.smtp.port", config.port.toInt().toString())
+      put("mail.smtp.auth", "true")
+      put("mail.smtp.connectiontimeout", config.timeout.toInt().toString())
+      put("mail.smtp.timeout", config.timeout.toInt().toString())
+      put("mail.smtp.writetimeout", config.timeout.toInt().toString())
+      put("mail.transport.protocol", "smtp")
+      put("mail.smtp.sendpartial", "true")
+
+      // ── SSL/TLS 配置 ──────────────────────────────────────
+      if (config.tls) {
+        put("mail.smtp.ssl.enable", "true")
+      }
+
+      // 若 checkCertificate=false，使用信任所有证书的 SocketFactory
+      if (!config.checkCertificate) {
+        put("mail.smtp.ssl.socketFactory", trustAllSocketFactory)
+        put("mail.smtp.ssl.socketFactory.fallback", "false")
+      }
+
+      if (config.debug) put("mail.debug", "true")
+    }
+    return Session.getInstance(props)
+  }
+
+  /** 确保文件夹已打开，若连接断开则自动重连 store 并重开文件夹 */
+  private fun ensureFolderOpen(): IMAPFolder {
+    ensureStoreConnected()  // 先确保底层 Store 连接存活
+    val folder = imapFolder ?: throw Exception("No mailbox selected. Call imapSelectMailbox first.")
+    if (!folder.isOpen()) {
+      Log.w(TAG, "Folder was closed by server, re-opening: $selectedMailbox")
+      folder.open(Folder.READ_WRITE)
+      Log.d(TAG, "Folder re-opened: $selectedMailbox")
+    }
+    return folder
+  }
+
+  private fun ensureImapStore(): IMAPStore {
+    return imapStore ?: throw Exception("Not connected to IMAP server.")
+  }
+
+  /** 确保 IMAP Store 连接存活，若已断开则自动使用保存的配置重连 */
+  private fun ensureStoreConnected(): IMAPStore {
+    val store = ensureImapStore()
+    if (!store.isConnected()) {
+      val config = imapConfig ?: throw Exception("IMAP store disconnected and no config available for reconnection")
+      Log.w(TAG, "IMAP store connection lost, reconnecting to ${config.host}...")
+      store.connect(config.username, config.password)
+      // 重连后重新发送 ID 命令（网易邮箱要求）
+      try {
+        store.id(buildIdMap(config.username))
+        Log.d(TAG, "Reconnect: ID command sent")
+      } catch (_: Exception) {
+        Log.d(TAG, "Reconnect: ID command not supported")
+      }
+      // 重连后之前的 folder 引用已失效，清除以触发重新选择
+      if (imapFolder != null) {
+        Log.w(TAG, "Store reconnected, previously selected mailbox ($selectedMailbox) folder is stale")
+        imapFolder = null
+        selectedMailbox = null
+      }
+    }
+    return store
+  }
+
+  // ─── 保活（Keep-Alive）────────────────────────────────────
+  // 定期发送 NOOP 命令防止 IMAP 服务器因空闲超时断开连接
+
+  @Volatile
+  private var keepAliveRunning = false
+  private var keepAliveThread: Thread? = null
+
+  private fun startKeepAlive() {
+    stopKeepAlive()
+    keepAliveRunning = true
+    val t = object : Thread("imap-keepalive") {
+      override fun run() {
+        while (keepAliveRunning) {
+          try {
+            Thread.sleep(60_000) // 每 60 秒发送一次 NOOP
+            if (!keepAliveRunning) break
+            val folder = imapFolder
+            if (folder != null && folder.isOpen()) {
+              folder.doCommand { protocol ->
+                protocol.simpleCommand("NOOP", null)
+                null
+              }
+              Log.v(TAG, "Keep-alive NOOP sent")
+            }
+          } catch (_: InterruptedException) { break }
+          catch (_: Exception) { /* NOOP 失败忽略，连接断开后由 ensureStoreConnected 处理 */ }
+        }
+      }
+    }
+    t.isDaemon = true
+    t.start()
+    keepAliveThread = t
+    Log.d(TAG, "Keep-alive started (60s interval)")
+  }
+
+  private fun stopKeepAlive() {
+    keepAliveRunning = false
+    keepAliveThread?.interrupt()
+    keepAliveThread = null
+  }
+
+  // ─── 邮件解析 ─────────────────────────────────────────────
+
+  private fun emailToEmailMessage(msg: Message, folder: IMAPFolder): EmailMessage {
+    val mime = msg as? MimeMessage ?: return EmailMessage(
+      uid = 0.0, sequenceNumber = msg.messageNumber.toDouble(),
+      subject = "", from = EmailAddress("", ""), to = emptyArray(),
+      cc = emptyArray(), bcc = emptyArray(), replyTo = emptyArray(),
+      date = "", receivedDate = "",
+      body = EmailBody("", "", emptyArray()), attachments = emptyArray(),
+      flags = flagsToArray(msg.flags), headers = emptyMap(),
+      size = msg.size.toDouble(), messageId = "",
+      inReplyTo = "", references = "", priority = "normal",
+      isEncrypted = false, mimeType = "", charset = "UTF-8"
+    )
+
+    val uid = try { folder.getUID(msg).toDouble() } catch (_: Exception) { 0.0 }
+    val from = addressToEmailAddress(msg.from?.firstOrNull())
+    val to = parseAddressList(msg.getRecipients(Message.RecipientType.TO))
+    val cc = parseAddressList(msg.getRecipients(Message.RecipientType.CC))
+    val bcc = parseAddressList(msg.getRecipients(Message.RecipientType.BCC))
+    val replyTo = parseAddressList(msg.replyTo)
+
+    val sentDate = msg.sentDate?.toISO8601() ?: ""
+    val receivedDate = msg.receivedDate?.toISO8601() ?: ""
+
+    var bodyText = ""
+    var bodyHtml = ""
+    val embeddedAttachments = mutableListOf<String>()
+    val attachments = mutableListOf<AttachmentInfo>()
+
+    try {
+      parseBodyParts(mime,
+        onText = { bodyText = it },
+        onHtml = { bodyHtml = it },
+        onEmbedded = { embeddedAttachments.add(it) },
+        onAttachment = { attachments.add(it) })
+    } catch (_: Exception) {
+      bodyText = mime.content?.toString() ?: ""
+    }
+
+    val headers = mutableMapOf<String, String>()
+    try {
+      mime.allHeaders?.toList()?.forEach { header ->
+        if (headers.size < 64) headers[header.name] = header.value
+      }
+    } catch (_: Exception) {}
+
+    return EmailMessage(
+      uid = uid,
+      sequenceNumber = msg.messageNumber.toDouble(),
+      subject = mime.subject ?: "",
+      from = from,
+      to = to, cc = cc, bcc = bcc, replyTo = replyTo,
+      date = sentDate,
+      receivedDate = receivedDate,
+      body = EmailBody(text = bodyText, html = bodyHtml, embeddedAttachments = embeddedAttachments.toTypedArray()),
+      attachments = attachments.toTypedArray(),
+      flags = flagsToArray(msg.flags),
+      headers = headers,
+      size = msg.size.toDouble(),
+      messageId = mime.messageID ?: "",
+      inReplyTo = mime.getHeader("In-Reply-To", null) ?: "",
+      references = mime.getHeader("References", null) ?: "",
+      priority = extractPriority(mime),
+      isEncrypted = false,
+      mimeType = mime.contentType ?: "",
+      charset = extractCharset(mime)
+    )
+  }
+
+  private fun parseBodyParts(
+    part: Part,
+    onText: (String) -> Unit,
+    onHtml: (String) -> Unit,
+    onEmbedded: (String) -> Unit,
+    onAttachment: (AttachmentInfo) -> Unit,
+  ) {
+    if (part.isMimeType("text/plain")) {
+      onText(part.content?.toString() ?: "")
+    } else if (part.isMimeType("text/html")) {
+      onHtml(part.content?.toString() ?: "")
+    } else if (part.isMimeType("multipart/alternative")) {
+      val mp = part.content as? Multipart ?: return
+      var foundHtml = false
+      var foundText = false
+      for (i in 0 until mp.count) {
+        val bp = mp.getBodyPart(i)
+        if (bp.isMimeType("text/html") && !foundHtml) {
+          onHtml(bp.content?.toString() ?: ""); foundHtml = true
+        } else if (bp.isMimeType("text/plain") && !foundText) {
+          onText(bp.content?.toString() ?: ""); foundText = true
+        }
+      }
+    } else if (part.isMimeType("multipart/*")) {
+      val mp = part.content as? Multipart ?: return
+      for (i in 0 until mp.count) {
+        parseBodyParts(mp.getBodyPart(i), onText, onHtml, onEmbedded, onAttachment)
+      }
+    } else {
+      val disp = part.disposition ?: ""
+      val isAttachment = disp.equals(Part.ATTACHMENT, ignoreCase = true)
+      val isInline = disp.equals(Part.INLINE, ignoreCase = true)
+      val contentId = (part as? MimeBodyPart)?.contentID
+      val fileName = part.fileName ?: contentId ?: "unnamed"
+
+      if (isAttachment || isInline || contentId != null) {
+        val info = readAttachmentData(part as BodyPart, fileName, contentId, isInline, disp)
+        if (isInline && contentId != null) {
+          onEmbedded(fileName)
+        }
+        if (isAttachment || (isInline && contentId == null)) {
+          onAttachment(info)
+        }
+      }
+    }
+  }
+
+  private fun readAttachmentData(
+    part: BodyPart, fileName: String, contentId: String?,
+    isInline: Boolean, disp: String
+  ): AttachmentInfo {
+    // 先保存到缓存文件，避免 OOM
+    var localPath: String? = null
+    val baos = ByteArrayOutputStream(minOf(MAX_ATTACHMENT_SIZE, 64 * 1024).toInt())
+    val input = part.inputStream
+    if (input == null) {
+      return AttachmentInfo(
+        filename = fileName,
+        mimeType = part.contentType ?: "application/octet-stream",
+        partId = contentId ?: fileName,
+        size = 0.0,
+        data = ArrayBuffer.copy(ByteArray(0)),
+        contentId = contentId,
+        inline = isInline,
+        charset = part.contentType?.let { extractCharsetFromMimeType(it) },
+        contentDisposition = disp,
+        localPath = null
+      )
+    }
+    try {
+      input.use { stream ->
+        // 生成唯一的缓存文件名
+        val cacheFile = File(ATTACHMENT_CACHE_DIR, "${UUID.randomUUID()}_${fileName.sanitizeFileName()}")
+        try {
+          FileOutputStream(cacheFile).use { fileOut ->
+            val buf = ByteArray(8192)
+            var total = 0L
+            var n: Int
+            while (stream.read(buf).also { n = it } != -1) {
+              if (total + n > MAX_ATTACHMENT_SIZE) {
+                val remaining = (MAX_ATTACHMENT_SIZE - total).toInt()
+                baos.write(buf, 0, remaining)
+                fileOut.write(buf, 0, remaining)
+                total = MAX_ATTACHMENT_SIZE
+                break
+              }
+              baos.write(buf, 0, n)
+              fileOut.write(buf, 0, n)
+              total += n
+            }
+          }
+          localPath = cacheFile.absolutePath
+        } catch (e: Exception) {
+          cacheFile.delete()
+          throw e
+        }
+      }
+    } catch (_: Exception) {}
+    val byteArray = try {
+      baos.toByteArray()
+    } catch (e: OutOfMemoryError) {
+      Log.e(TAG, "Attachment too large for memory: $fileName, using cache file")
+      // OOM 时至少返回缓存文件路径，前端可通过 localPath 读取
+      ByteArray(0)
+    }
+    return AttachmentInfo(
+      filename = fileName,
+      mimeType = part.contentType ?: "application/octet-stream",
+      partId = contentId ?: fileName,
+      size = baos.size().toDouble(),
+      data = ArrayBuffer.copy(byteArray),
+      contentId = contentId,
+      inline = isInline,
+      charset = part.contentType?.let { extractCharsetFromMimeType(it) },
+      contentDisposition = disp,
+      localPath = localPath
+    )
+  }
+
+  /** 清理文件名中的非法字符 */
+  private fun String.sanitizeFileName(): String {
+    return replace(Regex("""[<>:"/\\|?*]"""), "_")
+      .take(128)
+  }
+
+  private fun extractPriority(mime: MimeMessage): String {
+    val importance = mime.getHeader("Importance", null)
+    val priority = mime.getHeader("Priority", null) ?: mime.getHeader("X-Priority", null)
+    return when {
+      importance?.equals("high", ignoreCase = true) == true -> "high"
+      importance?.equals("low", ignoreCase = true) == true -> "low"
+      priority?.startsWith("1") == true || priority?.startsWith("2") == true -> "high"
+      priority?.startsWith("4") == true || priority?.startsWith("5") == true -> "low"
+      else -> "normal"
+    }
+  }
+
+  private fun extractCharset(mime: MimeMessage): String {
+    val ct = mime.contentType ?: return "UTF-8"
+    return extractCharsetFromMimeType(ct) ?: "UTF-8"
+  }
+
+  private fun extractCharsetFromMimeType(mimeType: String): String? {
+    val regex = """charset\s*=\s*([^\s;"]+)""".toRegex(RegexOption.IGNORE_CASE)
+    return regex.find(mimeType)?.groupValues?.getOrNull(1)
+  }
+
+  private fun addressToEmailAddress(addr: Address?): EmailAddress {
+    if (addr is InternetAddress) {
+      val personal = addr.personal ?: ""
+      return try {
+        EmailAddress(name = MimeUtility.decodeText(personal), email = addr.address)
+      } catch (_: Exception) {
+        EmailAddress(name = personal, email = addr.address)
+      }
+    }
+    return EmailAddress(name = "", email = addr?.toString() ?: "")
+  }
+
+  private fun flagsToArray(flags: Flags?): Array<String> {
+    if (flags == null) return emptyArray()
+    val result = mutableListOf<String>()
+    if (flags.contains(Flags.Flag.SEEN)) result.add("seen")
+    if (flags.contains(Flags.Flag.ANSWERED)) result.add("answered")
+    if (flags.contains(Flags.Flag.FLAGGED)) result.add("flagged")
+    if (flags.contains(Flags.Flag.DELETED)) result.add("deleted")
+    if (flags.contains(Flags.Flag.DRAFT)) result.add("draft")
+    if (flags.contains(Flags.Flag.RECENT)) result.add("recent")
+    flags.getUserFlags().forEach { result.add(it) }
+    return result.toTypedArray()
+  }
+
+  private fun parseAddressList(recipients: Array<out Address>?): Array<EmailAddress> {
+    return recipients?.filterIsInstance<InternetAddress>()
+      ?.map { addressToEmailAddress(it) }
+      ?.toTypedArray() ?: emptyArray()
+  }
+
+  /** 构造 IMAP ID 命令参数 (RFC 2971)，用于网易邮箱等要求 ID 命令的服务器 */
+  private fun buildIdMap(username: String?): java.util.HashMap<String, String> {
+    return java.util.HashMap<String, String>().apply {
+      put("name", "react-native-email-imap-smtp")
+      put("version", "1.0.0")
+      put("vendor", "react-native-email-imap-smtp")
+      put("support-email", username ?: "")
+      put("os", "Android")
+      put("os-version", System.getProperty("os.version") ?: "unknown")
+    }
+  }
+
+  /** 解析 "dd-MMM-yyyy" 格式的日期字符串（如 "01-Jan-2026"） */
+  private fun parseDateString(dateStr: String?): Date? {
+    if (dateStr == null) return null
+    return try {
+      java.text.SimpleDateFormat("dd-MMM-yyyy", java.util.Locale.ENGLISH).parse(dateStr)
+    } catch (_: Exception) { null }
+  }
+
+  // 日期格式化（DateTimeFormatter 是线程安全的，无需 ThreadLocal）
+  private val dateFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ssZ")
+
+  private fun Date.toISO8601(): String {
+    return ZonedDateTime.ofInstant(this.toInstant(), ZoneId.systemDefault())
+      .format(dateFormatter)
+  }
+
+  // ═══ IMAP — Connection ═════════════════════════════════════
+
+  override fun imapConnect(config: ConnectionConfig): Promise<ConnectionResult> {
+    return Promise.async {
+      try {
+        val session = imapSession(config)
+        val store = session.store as? IMAPStore
+          ?: return@async ConnectionResult(success = false, serverInfo = null, error = "Failed to create IMAP store")
+        store.connect(config.username, config.password)
+
+        // ── 发送 IMAP ID 命令 (RFC 2971) ─────────────────────
+        // 网易邮箱（163/188）要求客户端在认证后发送 ID 命令标识自身，
+        // 否则后续 SELECT 等操作会被拒绝并返回 "Unsafe Login"
+        try {
+          store.id(buildIdMap(config.username))
+          Log.d(TAG, "IMAP ID command sent successfully")
+        } catch (e: Exception) {
+          // 部分服务器（如 Gmail）不支持 ID 命令，此错误可安全忽略
+          Log.d(TAG, "IMAP ID command not supported by server: ${e.message}")
+        }
+
+        imapStore = store
+        imapConfig = config
+        ConnectionResult(
+          success = true,
+          serverInfo = Variant_ImapServerInfo_SmtpServerInfo.create(
+            ImapServerInfo(
+              serverName = config.host,
+              capabilities = emptyArray(),
+              isCompressed = false
+            )
+          ),
+          error = null
+        )
+      } catch (e: Exception) {
+        Log.e(TAG, "IMAP connect failed", e)
+        ConnectionResult(success = false, serverInfo = null, error = e.message)
+      }
+    }
+  }
+
+  override fun imapDisconnect(): Promise<Unit> {
+    return Promise.async {
+      stopKeepAlive()  // 停止保活
+      try { imapFolder?.close(false) } catch (_: Exception) {}
+      try { imapStore?.close() } catch (_: Exception) {}
+      imapFolder = null; imapStore = null; selectedMailbox = null; imapConfig = null
+    }
+  }
+
+  // ═══ IMAP — Mailbox ════════════════════════════════════════
+
+  override fun imapListMailboxes(): Promise<Array<MailboxListItem>> {
+    return Promise.async {
+      val store = ensureStoreConnected()
+      val result = mutableListOf<MailboxListItem>()
+      try {
+        store.defaultFolder.list("*").forEach { f ->
+          result.add(
+            MailboxListItem(
+              name = f.name ?: "", path = f.fullName ?: "",
+              delimiter = f.separator.toString(), flags = emptyArray(),
+              subscribed = f.isSubscribed
+            )
+          )
+        }
+      } catch (e: Exception) {
+        Log.e(TAG, "List mailboxes failed", e)
+      }
+      result.toTypedArray()
+    }
+  }
+
+  override fun imapSelectMailbox(mailbox: String, readOnly: Boolean): Promise<MailboxInfo> {
+    return Promise.async {
+      val store = ensureStoreConnected()  // 先确保 Store 连接存活
+      val raw = store.getFolder(mailbox) ?: throw Exception("Mailbox not found: $mailbox")
+      val folder = raw as? IMAPFolder ?: throw Exception("Mailbox is not an IMAP folder: $mailbox")
+
+      // ── 在 folder 连接上发送 ID 命令 ─────────────────────
+      // 对于网易邮箱等要求 ID 命令的服务器，必须在同一个连接上发送 ID 命令
+      try {
+        folder.doCommand { protocol ->
+          protocol.id(buildIdMap(imapConfig?.username))
+          null
+        }
+        Log.d(TAG, "ID command sent on folder connection")
+      } catch (e: Exception) {
+        Log.d(TAG, "ID command on folder not supported: ${e.message}")
+      }
+
+      try {
+        folder.open(if (readOnly) Folder.READ_ONLY else Folder.READ_WRITE)
+      } catch (e: jakarta.mail.MessagingException) {
+        val msg = e.message ?: ""
+        // ── 网易邮箱 "Unsafe Login" 特殊处理 ─────────────────
+        // 如果 SELECT 仍然被拒，给出明确指引
+        if (msg.contains("Unsafe Login", ignoreCase = true) || msg.contains("NO SELECT", ignoreCase = true)) {
+          throw Exception("IMAP 登录被服务器拒绝（Unsafe Login）。请确保：\n" +
+            "1. 已在网页端开启 IMAP/SMTP 服务\n" +
+            "2. 使用「授权码」而非登录密码\n" +
+            "3. 若仍未解决，请登录 ${imapConfig?.host ?: "网易邮箱"} 网页版完成一次安全验证后重试")
+        } else {
+          // 非 "Unsafe Login" 错误，直接抛出
+          throw Exception("选择邮箱 '$mailbox' 失败: ${e.message}", e)
+        }
+      }
+      imapFolder = folder; selectedMailbox = mailbox
+      startKeepAlive()  // 选择邮箱成功后启动保活
+
+      // 计算第一封未读邮件的 UID
+      val firstUnseenUid = try {
+        val unseen = folder.search(FlagTerm(Flags().apply { add(Flags.Flag.SEEN) }, false))
+        if (unseen.isNotEmpty()) folder.getUID(unseen[0]).toDouble() else 0.0
+      } catch (_: Exception) { 0.0 }
+
+      MailboxInfo(
+        name = folder.name ?: mailbox, path = folder.fullName ?: mailbox,
+        uidNext = folder.uidNext.toDouble(),
+        uidValidity = folder.uidValidity.toDouble(),
+        messageCount = folder.messageCount.toDouble(),
+        recentCount = folder.newMessageCount.toDouble(),
+        unseenCount = folder.unreadMessageCount.toDouble(),
+        firstUnseenUid = firstUnseenUid, highestModSeq = 0.0,
+        flags = emptyArray(), permanentFlags = emptyArray()
+      )
+    }
+  }
+
+  override fun imapRefreshMailbox(): Promise<MailboxInfo> {
+    return Promise.async {
+      val f = ensureFolderOpen()
+      val firstUnseenUid = try {
+        val unseen = f.search(FlagTerm(Flags().apply { add(Flags.Flag.SEEN) }, false))
+        if (unseen.isNotEmpty()) f.getUID(unseen[0]).toDouble() else 0.0
+      } catch (_: Exception) { 0.0 }
+      MailboxInfo(
+        name = f.name ?: "", path = f.fullName ?: "",
+        uidNext = f.uidNext.toDouble(),
+        uidValidity = f.uidValidity.toDouble(),
+        messageCount = f.messageCount.toDouble(),
+        recentCount = f.newMessageCount.toDouble(),
+        unseenCount = f.unreadMessageCount.toDouble(),
+        firstUnseenUid = firstUnseenUid, highestModSeq = 0.0,
+        flags = emptyArray(), permanentFlags = emptyArray()
+      )
+    }
+  }
+
+  // ═══ IMAP — Folders ════════════════════════════════════════
+
+  override fun imapFetchFolders(): Promise<Array<FolderInfo>> {
+    return Promise.async {
+      val store = ensureStoreConnected()
+      val result = mutableListOf<FolderInfo>()
+      try {
+        store.defaultFolder.list("*").forEach { f ->
+          result.add(
+            FolderInfo(
+              name = f.name ?: "", path = f.fullName ?: "",
+              delimiter = f.separator.toString(),
+              parent = f.parent?.fullName ?: "",
+              children = emptyArray(), flags = emptyArray(),
+              subscribed = f.isSubscribed,
+              messageCount = 0.0, unseenCount = 0.0
+            )
+          )
+        }
+      } catch (e: Exception) {
+        Log.e(TAG, "Fetch folders failed", e)
+      }
+      result.toTypedArray()
+    }
+  }
+
+  override fun imapCreateFolder(folderName: String): Promise<Unit> {
+    return Promise.async {
+      val folder = ensureStoreConnected().getFolder(folderName)
+      if (folder.exists()) {
+        Log.w(TAG, "Folder already exists: $folderName")
+        return@async
+      }
+      val created = folder.create(Folder.HOLDS_MESSAGES)
+      if (!created) throw Exception("Failed to create folder: $folderName (server returned false)")
+      Log.d(TAG, "Folder created: $folderName")
+    }
+  }
+
+  override fun imapDeleteFolder(folderName: String): Promise<Unit> {
+    return Promise.async {
+      val folder = ensureStoreConnected().getFolder(folderName)
+      if (!folder.exists()) {
+        Log.w(TAG, "Folder not found for deletion: $folderName")
+        return@async
+      }
+      folder.delete(false)
+      Log.d(TAG, "Folder deleted: $folderName")
+    }
+  }
+
+  override fun imapRenameFolder(oldName: String, newName: String): Promise<Unit> {
+    return Promise.async {
+      val s = ensureStoreConnected()
+      val folder = s.getFolder(oldName)
+      if (!folder.exists()) throw Exception("Folder not found: $oldName")
+      val renamed = folder.renameTo(s.getFolder(newName))
+      if (!renamed) throw Exception("Failed to rename folder: $oldName → $newName")
+      Log.d(TAG, "Folder renamed: $oldName → $newName")
+    }
+  }
+
+  override fun imapSubscribeFolder(folderName: String): Promise<Unit> {
+    return Promise.async { ensureStoreConnected().getFolder(folderName).setSubscribed(true) }
+  }
+
+  override fun imapUnsubscribeFolder(folderName: String): Promise<Unit> {
+    return Promise.async { ensureStoreConnected().getFolder(folderName).setSubscribed(false) }
+  }
+
+  // ═══ IMAP — Fetch ══════════════════════════════════════════
+
+  override fun imapFetchEmails(options: FetchEmailsOptions): Promise<Array<EmailMessage>> {
+    return Promise.async {
+      val result = mutableListOf<EmailMessage>()
+
+      fun doFetch(): Array<Message> {
+        // 若指定了 mailbox，先切换到该邮箱
+        if (options.mailbox != null && options.mailbox != selectedMailbox) {
+          val store = ensureStoreConnected()
+          val raw = store.getFolder(options.mailbox) ?: throw Exception("Mailbox not found: ${options.mailbox}")
+          val f = raw as? IMAPFolder ?: throw Exception("Not an IMAP folder: ${options.mailbox}")
+          if (!f.isOpen()) {
+            try {
+              f.doCommand { protocol ->
+                protocol.id(buildIdMap(imapConfig?.username))
+                null
+              }
+            } catch (_: Exception) {}
+            f.open(Folder.READ_WRITE)
+          }
+          imapFolder = f; selectedMailbox = options.mailbox
+        }
+
+        val folder = ensureFolderOpen()
+
+        // ── 时间范围过滤：使用 ReceivedDateTerm 搜索 ──────────
+        val sinceDate = parseDateString(options.since)
+        val beforeDate = parseDateString(options.before)
+        val hasTimeRange = sinceDate != null || beforeDate != null
+
+        if (hasTimeRange) {
+          val dateTerms = mutableListOf<ReceivedDateTerm>()
+          sinceDate?.let { dateTerms.add(ReceivedDateTerm(ReceivedDateTerm.GE, it)) }
+          beforeDate?.let { dateTerms.add(ReceivedDateTerm(ReceivedDateTerm.LT, it)) }
+          val dateSearchTerm = if (dateTerms.size == 1) dateTerms[0] else jakarta.mail.search.AndTerm(dateTerms.toTypedArray())
+          val allMsgs = folder.search(dateSearchTerm)
+          // 时间范围内支持分页
+          return if (options.page != null) {
+            val page = options.page!!.toInt()
+            val size = (options.pageSize ?: 20.0).toInt().coerceIn(1, MAX_FETCH_COUNT)
+            val startIdx = (page - 1) * size
+            val endIdx = minOf(startIdx + size, allMsgs.size)
+            if (startIdx >= allMsgs.size) emptyArray()
+            else allMsgs.sliceArray(startIdx until endIdx).sortedByDescending { it.receivedDate?.time ?: 0L }.toTypedArray()
+          } else {
+            allMsgs.sortedByDescending { it.receivedDate?.time ?: 0L }.take(20).toTypedArray()
+          }
+        }
+
+        // ── 无时间过滤：使用原有的范围/分页/默认逻辑 ──────────
+        return when {
+          // UID 范围模式
+          options.from != null && options.to != null && options.rangeType == "uid" -> {
+            val startUid = options.from!!.toLong()
+            val endUid = options.to!!.toLong()
+            val uidMsgs = folder.getMessagesByUID(startUid, endUid)
+            if (uidMsgs.size > MAX_FETCH_COUNT) uidMsgs.sliceArray(0 until MAX_FETCH_COUNT) else uidMsgs
+          }
+          // 序列号范围模式
+          options.from != null && options.to != null -> {
+            val start = options.from!!.toInt()
+            val end = options.to!!.toInt()
+            if (end - start + 1 > MAX_FETCH_COUNT) throw Exception("Fetch range too large (max $MAX_FETCH_COUNT per request)")
+            folder.getMessages(start, end)
+          }
+          // 分页模式
+          options.page != null -> {
+            val page = options.page!!.toInt()
+            val size = (options.pageSize ?: 20.0).toInt().coerceIn(1, MAX_FETCH_COUNT)
+            val allMsgs = folder.messages
+            val totalMsgs = allMsgs.size
+            val endIdx = totalMsgs - (page - 1) * size - 1
+            val startIdx = endIdx - size + 1
+            val s = startIdx.coerceAtLeast(0)
+            val e = endIdx.coerceAtLeast(0)
+            if (s > e) emptyArray() else allMsgs.sliceArray(s..e)
+          }
+          // 默认返回最近 20 封
+          else -> {
+            val total = folder.messageCount
+            val start = (total - 20).coerceAtLeast(1)
+            folder.getMessages(start, total)
+          }
+        }
+      }
+
+      val msgs = try {
+        doFetch()
+      } catch (e: jakarta.mail.FolderClosedException) {
+        Log.w(TAG, "FolderClosedException in imapFetchEmails, re-opening and retrying: ${e.message}")
+        doFetch()
+      }
+
+      try {
+        msgs.forEach { result.add(emailToEmailMessage(it, ensureFolderOpen())) }
+      } catch (e: Exception) {
+        Log.e(TAG, "Fetch emails failed", e)
+      }
+      result.toTypedArray()
+    }
+  }
+
+  override fun imapFetchEmailByUID(uid: Double): Promise<Variant_NullType_EmailMessage> {
+    return Promise.async {
+      try {
+        val folder = ensureFolderOpen()
+        val msg = folder.getMessageByUID(uid.toLong())
+        if (msg != null) {
+          return@async Variant_NullType_EmailMessage.create(emailToEmailMessage(msg, folder))
+        }
+      } catch (e: Exception) {
+        Log.e(TAG, "Fetch by UID failed", e)
+      }
+      Variant_NullType_EmailMessage.create(com.margelo.nitro.core.NullType.NULL)
+    }
+  }
+
+  // ═══ IMAP — Search ═════════════════════════════════════════
+
+  override fun imapSearchEmails(criteria: SearchCriteria): Promise<Array<EmailMessage>> {
+    return Promise.async {
+      val result = mutableListOf<EmailMessage>()
+
+      try {
+        // ── 若指定了 mailbox，先切换到该邮箱（略过已选中的）─
+        if (criteria.mailbox != null && criteria.mailbox != selectedMailbox) {
+          val store = ensureStoreConnected()
+          val raw = store.getFolder(criteria.mailbox) ?: throw Exception("Mailbox not found: ${criteria.mailbox}")
+          val f = raw as? IMAPFolder ?: throw Exception("Not an IMAP folder: ${criteria.mailbox}")
+          if (!f.isOpen()) {
+            try {
+              f.doCommand { protocol ->
+                protocol.id(buildIdMap(imapConfig?.username))
+                null
+              }
+            } catch (_: Exception) {}
+            f.open(Folder.READ_WRITE)
+          }
+          imapFolder = f; selectedMailbox = criteria.mailbox
+        }
+
+        val folder = ensureFolderOpen()
+
+        // ── 处理 UIDs 特例：直接按 UID 列表获取，忽略其他条件 ──
+        if (criteria.uids != null && criteria.uids.isNotEmpty()) {
+          val uidList = criteria.uids.map { it.toLong() }
+          val msgs = uidList.mapNotNull { uid ->
+            try { folder.getMessageByUID(uid) } catch (_: Exception) { null }
+          }
+          val limit = minOf(criteria.limit?.toInt() ?: msgs.size, msgs.size, MAX_FETCH_COUNT)
+          val sorted = msgs.sortedByDescending { it.receivedDate?.time ?: 0L }.take(limit)
+          sorted.forEach { result.add(emailToEmailMessage(it, folder)) }
+          return@async result.toTypedArray()
+        }
+
+        val terms = ArrayList<SearchTerm>()
+
+        // ── 基本文本搜索 ─────────────────────────────────────
+        criteria.subject?.let { terms.add(SubjectTerm(it)) }
+        criteria.from?.let { terms.add(FromStringTerm(it)) }
+        criteria.to?.let { terms.add(RecipientStringTerm(Message.RecipientType.TO, it)) }
+        criteria.body?.let { terms.add(BodyTerm(it)) }
+        // text: 同时搜索 subject 和 body
+        criteria.text?.let { terms.add(jakarta.mail.search.OrTerm(SubjectTerm(it), BodyTerm(it))) }
+
+        // ── 时间范围搜索 ─────────────────────────────────────
+        val sinceDate = parseDateString(criteria.since)
+        val beforeDate = parseDateString(criteria.before)
+        val onDate = parseDateString(criteria.on)
+        if (sinceDate != null) terms.add(ReceivedDateTerm(ReceivedDateTerm.GE, sinceDate))
+        if (beforeDate != null) terms.add(ReceivedDateTerm(ReceivedDateTerm.LT, beforeDate))
+        if (onDate != null) terms.add(ReceivedDateTerm(ReceivedDateTerm.EQ, onDate))
+
+        // 发送时间搜索
+        val sentSinceDate = parseDateString(criteria.sentSince)
+        val sentBeforeDate = parseDateString(criteria.sentBefore)
+        if (sentSinceDate != null) terms.add(SentDateTerm(SentDateTerm.GE, sentSinceDate))
+        if (sentBeforeDate != null) terms.add(SentDateTerm(SentDateTerm.LT, sentBeforeDate))
+
+        // ── 标志搜索 ─────────────────────────────────────────
+        if (criteria.seen != null) terms.add(FlagTerm(Flags().apply { add(Flags.Flag.SEEN) }, criteria.seen))
+        if (criteria.flagged != null) terms.add(FlagTerm(Flags().apply { add(Flags.Flag.FLAGGED) }, criteria.flagged))
+        if (criteria.answered != null) terms.add(FlagTerm(Flags().apply { add(Flags.Flag.ANSWERED) }, criteria.answered))
+        if (criteria.draft != null) terms.add(FlagTerm(Flags().apply { add(Flags.Flag.DRAFT) }, criteria.draft))
+        if (criteria.deleted != null) terms.add(FlagTerm(Flags().apply { add(Flags.Flag.DELETED) }, criteria.deleted))
+        if (criteria.junk != null) terms.add(FlagTerm(Flags().apply { add("Junk") }, criteria.junk))
+
+        // ── 邮件头搜索 ──────────────────────────────────────
+        criteria.header?.let { terms.add(HeaderTerm(it.key, it.value)) }
+
+        // ── 大小搜索 ─────────────────────────────────────────
+        criteria.larger?.let { terms.add(SizeTerm(SizeTerm.GT, it.toInt())) }
+        criteria.smaller?.let { terms.add(SizeTerm(SizeTerm.LT, it.toInt())) }
+
+        // ── 执行搜索 ─────────────────────────────────────────
+        val st = when (terms.size) { 0 -> null; 1 -> terms[0]; else -> AndTerm(terms.toTypedArray()) }
+        var rawMsgs = (st?.let { folder.search(it) } ?: folder.messages).toList()
+
+        // ── hasAttachment 过滤（IMAP 搜索不直接支持，需后过滤）─
+        if (criteria.hasAttachment == true) {
+          rawMsgs = rawMsgs.filter { msg ->
+            val ct = (msg as? MimeMessage)?.contentType ?: ""
+            ct.startsWith("multipart/mixed", ignoreCase = true) ||
+            ct.startsWith("multipart/related", ignoreCase = true) ||
+            ct.startsWith("multipart/signed", ignoreCase = true)
+          }
+        }
+
+        // ── 排序 ─────────────────────────────────────────────
+        val isAsc = criteria.sortOrder == "asc"
+        val sortedMsgs = if (isAsc) rawMsgs.sortedBy { it.receivedDate?.time ?: 0L }
+                         else rawMsgs.sortedByDescending { it.receivedDate?.time ?: 0L }
+
+        val limit = minOf(criteria.limit?.toInt() ?: sortedMsgs.size, sortedMsgs.size, MAX_FETCH_COUNT)
+        for (i in 0 until limit) {
+          result.add(emailToEmailMessage(sortedMsgs[i], folder))
+        }
+      } catch (e: Exception) {
+        Log.e(TAG, "Search failed", e)
+      }
+      result.toTypedArray()
+    }
+  }
+
+  // ═══ IMAP — Flags ══════════════════════════════════════════
+
+  override fun imapMarkAsRead(uids: DoubleArray, silent: Boolean): Promise<Unit> {
+    return Promise.async {
+      val folder = ensureFolderOpen()
+      uids.forEach { uid ->
+        try {
+          val msg = folder.getMessageByUID(uid.toLong()) ?: return@forEach
+          // silent: 仅设置 flags，不触发 FolderListener 事件
+          // 非 silent: 设置 flags 并等待服务器确认
+          msg.setFlag(Flags.Flag.SEEN, true)
+          if (!silent) {
+            // 非 silent 模式下强制同步到服务器
+            folder.fetch(arrayOf(msg), FetchProfile().apply { add(FetchProfile.Item.FLAGS) })
+          }
+        } catch (_: Exception) {}
+      }
+    }
+  }
+
+  override fun imapMarkAsFlagged(uids: DoubleArray, flagged: Boolean): Promise<Unit> {
+    return Promise.async {
+      val folder = ensureFolderOpen()
+      uids.forEach { uid ->
+        try {
+          val msg = folder.getMessageByUID(uid.toLong()) ?: return@forEach
+          if (flagged) msg.setFlags(Flags(Flags.Flag.FLAGGED), true)
+          else msg.setFlags(Flags(Flags.Flag.FLAGGED), false)
+        } catch (_: Exception) {}
+      }
+    }
+  }
+
+  // ═══ IMAP — Move / Copy / Delete ═══════════════════════════
+
+  override fun imapMoveEmails(uids: DoubleArray, destinationMailbox: String): Promise<Unit> {
+    return Promise.async {
+      val folder = ensureFolderOpen()
+      val store = ensureStoreConnected()
+
+      val msgs = uids.map { uid ->
+        try { folder.getMessageByUID(uid.toLong()) } catch (_: Exception) { null }
+      }.filterNotNull().toTypedArray()
+      if (msgs.isEmpty()) return@async
+
+      var lastError: Exception? = null
+      for (attempt in 0 until 3) {
+        val dest = store.getFolder(destinationMailbox)
+        if (!dest.exists()) {
+          Log.w(TAG, "Move: destination folder does not exist, creating: $destinationMailbox")
+          val created = dest.create(Folder.HOLDS_MESSAGES)
+          if (!created) throw Exception("Failed to create destination folder: $destinationMailbox (server returned false)")
+        }
+        try {
+          // 先复制到目标文件夹
+          folder.copyMessages(msgs, dest)
+          lastError = null
+          // 复制成功后，在原文件夹标记删除并 expunge
+          try {
+            msgs.forEach { it.setFlags(Flags(Flags.Flag.DELETED), true) }
+            ensureFolderOpen().expunge()
+          } catch (e: Exception) {
+            Log.e(TAG, "Move: expunge after copy failed: ${e.message}")
+          }
+          break // 成功
+        } catch (e: jakarta.mail.FolderNotFoundException) {
+          lastError = e
+          Log.w(TAG, "Move: folder not found (attempt $attempt), re-creating destination: ${e.message}")
+          try { dest.delete(false) } catch (_: Exception) {}
+        }
+      }
+      lastError?.let { throw it }
+    }
+  }
+
+  override fun imapCopyEmails(uids: DoubleArray, destinationMailbox: String): Promise<Unit> {
+    return Promise.async {
+      val folder = ensureFolderOpen()
+      val store = ensureStoreConnected()
+
+      val msgs = uids.map { uid ->
+        try { folder.getMessageByUID(uid.toLong()) } catch (_: Exception) { null }
+      }.filterNotNull().toTypedArray()
+      if (msgs.isEmpty()) return@async
+
+      // 163 邮箱等 IMAP 服务器可能在文件夹创建后仍返回 [TRYCREATE]，
+      // 此时需要删除并重新创建目标文件夹再重试
+      var lastError: Exception? = null
+      for (attempt in 0 until 3) {
+        val dest = store.getFolder(destinationMailbox)
+        if (!dest.exists()) {
+          Log.w(TAG, "Copy: destination folder does not exist, creating: $destinationMailbox")
+          val created = dest.create(Folder.HOLDS_MESSAGES)
+          if (!created) throw Exception("Failed to create destination folder: $destinationMailbox (server returned false)")
+        }
+        try {
+          folder.copyMessages(msgs, dest)
+          lastError = null
+          break // 成功
+        } catch (e: jakarta.mail.FolderNotFoundException) {
+          lastError = e
+          Log.w(TAG, "Copy: folder not found (attempt $attempt), re-creating destination: ${e.message}")
+          // 删除旧的文件夹引用，下次循环用新的 getFolder() 获取
+          try { dest.delete(false) } catch (_: Exception) {}
+        }
+      }
+      lastError?.let { throw it }
+    }
+  }
+
+  override fun imapDeleteEmails(uids: DoubleArray): Promise<DeleteResult> {
+    return Promise.async {
+      val success = mutableListOf<Double>()
+      val failed = mutableListOf<Double>()
+      uids.forEach { uid ->
+        var retried = false
+        while (true) {
+          try {
+            val folder = ensureFolderOpen()
+            val msg = folder.getMessageByUID(uid.toLong())
+            if (msg != null) {
+              msg.setFlags(Flags(Flags.Flag.DELETED), true)
+              success.add(uid)
+              Log.d(TAG, "Deleted UID=$uid")
+            } else {
+              Log.w(TAG, "Delete failed: message UID=$uid not found (already deleted?)")
+              failed.add(uid)
+            }
+            break
+          } catch (e: FolderClosedException) {
+            if (!retried) {
+              Log.w(TAG, "Folder closed during delete UID=$uid, re-opening and retrying...")
+              retried = true
+              continue
+            }
+            Log.e(TAG, "Delete failed for UID=$uid after retry: ${e.message}")
+            failed.add(uid)
+            break
+          } catch (e: Exception) {
+            Log.e(TAG, "Delete failed for UID=$uid: ${e.message}")
+            failed.add(uid)
+            break
+          }
+        }
+      }
+      // 对成功标记删除的邮件执行 EXPUNGE 彻底清除
+      if (success.isNotEmpty()) {
+        try {
+          ensureFolderOpen().expunge()
+          Log.d(TAG, "Expunge completed after deleting ${success.size} messages")
+        } catch (e: Exception) {
+          Log.e(TAG, "Expunge after delete failed: ${e.message}")
+        }
+      }
+      DeleteResult(
+        success = success.toDoubleArray(),
+        failed = failed.toDoubleArray(),
+        error = if (failed.isNotEmpty()) "${failed.size} messages failed" else null
+      )
+    }
+  }
+
+  override fun imapExpunge(): Promise<Unit> {
+    return Promise.async {
+      val folder = ensureFolderOpen()
+      folder.expunge()
+      Log.d(TAG, "Expunge completed")
+    }
+  }
+
+  // ═══ IMAP — Attachments ════════════════════════════════════
+
+  override fun imapFetchAttachments(uid: Double, partId: String): Promise<Variant_NullType_AttachmentInfo> {
+    return Promise.async {
+      try {
+        val folder = ensureFolderOpen()
+        val msg = folder.getMessageByUID(uid.toLong()) ?: return@async Variant_NullType_AttachmentInfo.create(com.margelo.nitro.core.NullType.NULL)
+        val result = findAttachmentByPartId(msg, partId)
+        if (result != null) {
+          return@async Variant_NullType_AttachmentInfo.create(result)
+        }
+      } catch (e: Exception) {
+        Log.e(TAG, "Fetch attachment failed", e)
+      }
+      Variant_NullType_AttachmentInfo.create(com.margelo.nitro.core.NullType.NULL)
+    }
+  }
+
+  override fun imapFetchAllAttachments(uid: Double): Promise<Array<AttachmentInfo>> {
+    return Promise.async {
+      val result = mutableListOf<AttachmentInfo>()
+      try {
+        val folder = ensureFolderOpen()
+        val msg = folder.getMessageByUID(uid.toLong()) ?: return@async result.toTypedArray()
+        collectAttachments(msg, result)
+      } catch (e: Exception) {
+        Log.e(TAG, "Fetch all attachments failed", e)
+      }
+      result.toTypedArray()
+    }
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  private fun findAttachmentByPartId(msg: Message, partId: String): AttachmentInfo? {
+    val content = msg.content
+    if (content is Multipart) {
+      for (i in 0 until content.count) {
+        val part = content.getBodyPart(i)
+        val disp = part.disposition ?: Part.ATTACHMENT
+        if (disp.equals(Part.ATTACHMENT, ignoreCase = true) || disp.equals(Part.INLINE, ignoreCase = true)) {
+          val fileName = part.fileName ?: "attachment_$i"
+          if (fileName == partId || i.toString() == partId) {
+            return readAttachmentData(part, fileName, (part as? MimeBodyPart)?.contentID,
+              disp.equals(Part.INLINE, ignoreCase = true), disp)
+          }
+        }
+        if (part.content is Multipart) {
+          @Suppress("UNCHECKED_CAST")
+          return findAttachmentByPartId(part as Message, partId)
+        }
+      }
+    }
+    return null
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  private fun collectAttachments(msg: Message, result: MutableList<AttachmentInfo>) {
+    val content = msg.content
+    if (content is Multipart) {
+      for (i in 0 until content.count) {
+        val part = content.getBodyPart(i)
+        val disp = part.disposition ?: Part.ATTACHMENT
+        if (disp.equals(Part.ATTACHMENT, ignoreCase = true) || disp.equals(Part.INLINE, ignoreCase = true)) {
+          result.add(readAttachmentData(part, part.fileName ?: "attachment_$i",
+            (part as? MimeBodyPart)?.contentID,
+            disp.equals(Part.INLINE, ignoreCase = true), disp))
+        }
+        if (part.content is Multipart) {
+          @Suppress("UNCHECKED_CAST")
+          collectAttachments(part as Message, result)
+        }
+      }
+    }
+  }
+
+  // ═══ IMAP — IDLE ═══════════════════════════════════════════
+
+  private val idleDispatcher = CoroutineScope(Executors.newSingleThreadExecutor().asCoroutineDispatcher() + SupervisorJob())
+
+  override fun imapIdle(callback: (IdleNotification) -> Unit): Promise<Unit> {
+    return Promise.async(idleDispatcher) {
+      if (isIdling) throw Exception("ALREADY_IDLE")
+      // 确保文件夹已打开，避免进入循环后因空指针退出
+      val folder = imapFolder ?: throw Exception("No mailbox selected. Call imapSelectMailbox first.")
+      isIdling = true
+      try {
+        while (isIdling) {
+          try {
+            folder.idle()
+            if (!isIdling) break
+            callback(
+              IdleNotification(
+                type = "newMessage",
+                mailbox = selectedMailbox ?: "",
+                uid = null, flag = null, messageCount = null,
+                timestamp = System.currentTimeMillis().toDouble()
+              )
+            )
+          } catch (e: jakarta.mail.FolderClosedException) {
+            break
+          } catch (_: Exception) {
+            if (!isIdling) break
+            callback(
+              IdleNotification(
+                type = "connectionLost",
+                mailbox = selectedMailbox ?: "",
+                uid = null, flag = null, messageCount = null,
+                timestamp = System.currentTimeMillis().toDouble()
+              )
+            )
+            break
+          }
+        }
+      } catch (_: Exception) {}
+    }
+  }
+
+  override fun imapStopIdle(): Promise<Unit> {
+    return Promise.async {
+      isIdling = false
+      // 发送 NOOP 唤醒 IDLE 循环
+      try {
+        ensureFolderOpen().doCommand { protocol ->
+          protocol.simpleCommand("NOOP", null)
+        }
+      } catch (_: Exception) {}
+    }
+  }
+
+  // ═══ IMAP — Quota ══════════════════════════════════════════
+
+  override fun imapGetQuota(root: String?): Promise<QuotaInfo> {
+    return Promise.async {
+      try {
+        val quotas = ensureStoreConnected().getQuota(root ?: "")
+        val r = quotas.firstOrNull()?.resources?.firstOrNull()
+        QuotaInfo(
+          storageUsed = r?.usage?.toDouble() ?: 0.0,
+          storageLimit = r?.limit?.toDouble() ?: -1.0,
+          storageUnit = "KB",
+          messagesUsed = null, messagesLimit = null,
+          root = root ?: ""
+        )
+      } catch (_: Exception) {
+        QuotaInfo(storageUsed = 0.0, storageLimit = -1.0, storageUnit = "KB",
+          messagesUsed = null, messagesLimit = null, root = root ?: "")
+      }
+    }
+  }
+
+  // ═══ IMAP — Append ═════════════════════════════════════════
+
+  override fun imapAppendMessage(mailbox: String, rawMimeData: ArrayBuffer, flags: Array<String>?): Promise<AppendResult> {
+    // ⚠️ 在 JS 线程拷贝数据，避免后台线程访问 ArrayBuffer.size() 报错
+    val mimeBytes = rawMimeData.toByteArray()
+    return Promise.async {
+      val store = ensureStoreConnected()
+
+      // ✅ 优先复用已打开的文件夹连接，避免触发 163 邮箱的 SELECT Unsafe Login
+      val folder = if (mailbox == selectedMailbox && imapFolder?.isOpen() == true) {
+        Log.d(TAG, "Append: reusing already-open folder: $mailbox")
+        imapFolder!!
+      } else {
+        val rawFolder = store.getFolder(mailbox) ?: throw Exception("Folder not found: $mailbox")
+        val f = rawFolder as? IMAPFolder
+          ?: throw Exception("Folder is not an IMAP folder: $mailbox")
+        // 🔴 打开文件夹前必须先发送 ID 命令（网易邮箱要求），否则 SELECT 会返回 "Unsafe Login"
+        if (!f.isOpen()) {
+          try {
+            f.doCommand { protocol ->
+              protocol.id(buildIdMap(imapConfig?.username))
+              null
+            }
+          } catch (_: Exception) {}
+          f.open(Folder.READ_WRITE)
+          Log.d(TAG, "Append: opened folder $mailbox for append")
+        }
+        f
+      }
+
+      val msg = MimeMessage(Session.getInstance(Properties()), mimeBytes.inputStream())
+      val messageId = msg.messageID
+
+      // ✅ 记录 append 前的邮件数量，用于后续通过 sequence number 查找新邮件
+      val countBefore = folder.messageCount
+      Log.d(TAG, "Append: messageCount before append = $countBefore")
+
+      folder.appendMessages(arrayOf(msg))
+
+      // 强制刷新文件夹状态，使服务器分配 UID 后能正确反映到本地缓存
+      folder.getMessageCount()
+
+      val countAfter = folder.messageCount
+      Log.d(TAG, "Append: messageCount after append = $countAfter")
+
+      // 策略 1: 通过 Message-ID 搜索来精确匹配刚追加的邮件
+      var uid = -1.0
+      if (messageId != null) {
+        try {
+          val searchTerm = HeaderTerm("Message-ID", messageId)
+          val found = folder.search(searchTerm)
+          if (found.isNotEmpty()) {
+            uid = try { folder.getUID(found[0]).toDouble() } catch (_: Exception) { -1.0 }
+          }
+        } catch (e: Exception) {
+          Log.w(TAG, "Append: Message-ID search failed: ${e.message}")
+        }
+      }
+
+      // 策略 2: 通过 uidNext 推断（新邮件 UID = append 前的 uidNext）
+      if (uid <= 0.0) {
+        val uidNext = folder.uidNext
+        if (uidNext > 0L) {
+          uid = uidNext.toDouble() - 1.0
+          Log.d(TAG, "Append: resolved UID via uidNext=$uidNext -> $uid")
+        }
+      }
+
+      // 策略 3: 通过 sequence number 获取（适用于服务器不支持 UIDNEXT 的情况）
+      if (uid <= 0.0 && countAfter > countBefore) {
+        try {
+          // 新邮件应该是最后一封，用 sequence number 获取
+          val lastMsg = folder.getMessage(countAfter)
+          if (lastMsg != null) {
+            uid = try { folder.getUID(lastMsg).toDouble() } catch (_: Exception) { -1.0 }
+            Log.d(TAG, "Append: resolved UID via sequence number (msg $countAfter) -> $uid")
+          }
+        } catch (e: Exception) {
+          Log.w(TAG, "Append: sequence number lookup failed: ${e.message}")
+        }
+      }
+
+      if (uid <= 0.0) {
+        throw Exception("Append succeeded but could not determine UID (countBefore=$countBefore, countAfter=$countAfter, uidNext=${folder.uidNext}, messageId=$messageId)")
+      }
+      Log.d(TAG, "Append: resolved UID=$uid for messageId=$messageId")
+
+      if (flags != null && flags.isNotEmpty()) {
+        try {
+          val uidVal = uid.toLong()
+          if (uidVal > 0L) {
+            val stored = folder.getMessageByUID(uidVal)
+            val jakartaFlags = Flags()
+            flags.forEach { f ->
+              when (f.lowercase()) {
+                "seen" -> jakartaFlags.add(Flags.Flag.SEEN)
+                "answered" -> jakartaFlags.add(Flags.Flag.ANSWERED)
+                "flagged" -> jakartaFlags.add(Flags.Flag.FLAGGED)
+                "deleted" -> jakartaFlags.add(Flags.Flag.DELETED)
+                "draft" -> jakartaFlags.add(Flags.Flag.DRAFT)
+                else -> jakartaFlags.add(f)
+              }
+            }
+            if (jakartaFlags.getSystemFlags().isNotEmpty() || jakartaFlags.getUserFlags().isNotEmpty()) stored?.setFlags(jakartaFlags, true)
+          }
+        } catch (_: Exception) {}
+      }
+
+      AppendResult(
+        uid = uid,
+        uidValidity = folder.uidValidity.toDouble(),
+        date = msg.receivedDate?.toISO8601() ?: ""
+      )
+    }
+  }
+
+  // ═══════════════════════════════════════════════════════════
+  //  SMTP
+  // ═══════════════════════════════════════════════════════════
+
+  override fun smtpConnect(config: SmtpConnectionConfig): Promise<ConnectionResult> {
+    return Promise.async {
+      try {
+        val session = smtpSession(config)
+        val transport = session.transport as? SMTPTransport
+          ?: return@async ConnectionResult(success = false, serverInfo = null, error = "Failed to create SMTP transport")
+        transport.connect(config.username, config.password)
+        smtpTransport = transport
+        smtpSessionCache = session
+        smtpConfig = config
+        ConnectionResult(
+          success = true,
+          serverInfo = Variant_ImapServerInfo_SmtpServerInfo.create(
+            SmtpServerInfo(
+              serverName = config.host,
+              capabilities = emptyArray(),
+              supportedAuthMethods = arrayOf("LOGIN", "PLAIN")
+            )
+          ),
+          error = null
+        )
+      } catch (e: Exception) {
+        Log.e(TAG, "SMTP connect failed", e)
+        ConnectionResult(success = false, serverInfo = null, error = e.message)
+      }
+    }
+  }
+
+  override fun smtpDisconnect(): Promise<Unit> {
+    return Promise.async {
+      try { smtpTransport?.close() } catch (_: Exception) {}
+      smtpTransport = null
+      smtpSessionCache = null
+      smtpConfig = null
+    }
+  }
+
+  override fun smtpSendMail(options: SendMailOptions): Promise<SendMailResult> {
+    // ⚠️ 在 JS 线程预拷贝附件数据，避免后台线程访问 ArrayBuffer.size() 报错
+    val preCopiedAttachments = options.attachments?.map { att ->
+      att.data.toByteArray()
+    }
+    return Promise.async {
+      val session = smtpSessionCache
+        ?: return@async SendMailResult(
+          success = false, messageId = null, date = null,
+          serverResponseCode = null, rawMimeData = null, queueId = null,
+          error = "SMTP not configured. Call smtpConnect first.", retryable = true
+        )
+
+      // 即用即连：每次发送创建临时连接，避免长连接失效
+      var tempTransport: SMTPTransport? = null
+      try {
+        val transport = session.transport as? SMTPTransport
+          ?: return@async SendMailResult(
+            success = false, messageId = null, date = null,
+            serverResponseCode = null, rawMimeData = null, queueId = null,
+            error = "Failed to create SMTP transport", retryable = true
+          )
+        tempTransport = transport
+        transport.connect(smtpConfig?.username, smtpConfig?.password)
+
+        val message = MimeMessage(session).apply {
+          setFrom(InternetAddress(options.from.email, options.from.name))
+          options.to.forEach { addRecipient(Message.RecipientType.TO, InternetAddress(it.email, it.name)) }
+          options.cc?.forEach { addRecipient(Message.RecipientType.CC, InternetAddress(it.email, it.name)) }
+          options.bcc?.forEach { addRecipient(Message.RecipientType.BCC, InternetAddress(it.email, it.name)) }
+          options.replyTo?.let { setReplyTo(it.map { a -> InternetAddress(a.email, a.name) }.toTypedArray()) }
+          setSubject(options.subject, "UTF-8")
+
+          val hasText = options.textBody != null
+          val hasHtml = options.htmlBody != null
+          val hasAttachments = options.attachments?.isNotEmpty() == true
+
+          when {
+            hasAttachments -> {
+              val mixed = MimeMultipart("mixed")
+              val altWrapper = MimeBodyPart().apply {
+                setContent(MimeMultipart("alternative").apply {
+                  if (hasText) addBodyPart(MimeBodyPart().apply { setText(options.textBody, "UTF-8") })
+                  if (hasHtml) addBodyPart(MimeBodyPart().apply { setContent(options.htmlBody, "text/html; charset=UTF-8") })
+                })
+              }
+              mixed.addBodyPart(altWrapper)
+              options.attachments!!.forEachIndexed { index, att ->
+                val bp = MimeBodyPart().apply {
+                  fileName = MimeUtility.encodeText(att.filename, "UTF-8", null)
+                  disposition = if (att.inline) Part.INLINE else Part.ATTACHMENT
+                  if (att.contentId != null) setContentID(att.contentId)
+                  setDataHandler(jakarta.activation.DataHandler(
+                    object : jakarta.activation.DataSource {
+                      override fun getInputStream() = preCopiedAttachments!![index].inputStream()
+                      override fun getOutputStream() = throw UnsupportedOperationException()
+                      override fun getContentType() = att.mimeType
+                      override fun getName() = att.filename
+                    }
+                  ))
+                }
+                mixed.addBodyPart(bp)
+              }
+              setContent(mixed)
+            }
+            hasHtml && hasText -> {
+              setContent(MimeMultipart("alternative").apply {
+                addBodyPart(MimeBodyPart().apply { setText(options.textBody, "UTF-8") })
+                addBodyPart(MimeBodyPart().apply { setContent(options.htmlBody, "text/html; charset=UTF-8") })
+              })
+            }
+            hasHtml -> setContent(options.htmlBody, "text/html; charset=UTF-8")
+            else -> setText(options.textBody ?: "", "UTF-8")
+          }
+
+          options.headers?.forEach { (key, value) -> addHeader(key, value) }
+          if (options.priority != null && options.priority != "normal") {
+            when (options.priority) {
+              "high" -> { addHeader("Priority", "urgent"); addHeader("X-Priority", "1") }
+              "low" -> { addHeader("Priority", "non-urgent"); addHeader("X-Priority", "5") }
+            }
+          }
+          if (options.inReplyTo != null) setHeader("In-Reply-To", options.inReplyTo)
+          if (options.references != null) setHeader("References", options.references)
+          options.readReceiptTo?.let {
+            setHeader("Disposition-Notification-To", "<${it.email}>")
+          }
+        }
+
+        transport.sendMessage(message, message.allRecipients)
+
+        val baos = ByteArrayOutputStream().let { message.writeTo(it); it }
+        SendMailResult(
+          success = true,
+          messageId = message.messageID ?: "",
+          date = message.sentDate?.toISO8601() ?: "",
+          serverResponseCode = 250.0,
+          rawMimeData = ArrayBuffer.copy(baos.toByteArray()),
+          queueId = null, error = null, retryable = false
+        )
+      } catch (e: jakarta.mail.SendFailedException) {
+        Log.e(TAG, "SMTP send partial failure", e)
+        SendMailResult(
+          success = false, messageId = null, date = null,
+          serverResponseCode = e.invalidAddresses?.firstOrNull()?.let { 550.0 },
+          rawMimeData = null, queueId = null,
+          error = "Send failed: ${e.message}", retryable = false
+        )
+      } catch (e: Exception) {
+        Log.e(TAG, "SMTP send failed", e)
+        SendMailResult(
+          success = false, messageId = null, date = null,
+          serverResponseCode = null, rawMimeData = null, queueId = null,
+          error = e.message, retryable = true
+        )
+      } finally {
+        try { tempTransport?.close() } catch (_: Exception) {}
+      }
+    }
+  }
+
+  override fun smtpVerifyConnection(): Promise<Boolean> {
+    return Promise.async {
+      try { smtpTransport?.isConnected == true } catch (_: Exception) { false }
+    }
+  }
+}