react-native-email-imap-smtp 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-email-imap-smtp",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "The best of imap and smtp client of react native",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/windows/EmailImapSmtp/EmailImapSmtp.vcxproj

@@ -7,6 +7,33 @@
 <Project ToolsVersion="Current" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <Import Project="$(MSBuildThisFileDirectory)..\ExperimentalFeatures.props" Condition="Exists('$(MSBuildThisFileDirectory)..\ExperimentalFeatures.props')" />
 
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+
   <PropertyGroup Label="Globals">
     <CppWinRTOptimized>true</CppWinRTOptimized>
     <CppWinRTRootNamespaceAutoMerge>true</CppWinRTRootNamespaceAutoMerge>
@@ -21,12 +48,15 @@
     <ApplicationTypeRevision>10.0</ApplicationTypeRevision>
   </PropertyGroup>
 
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-
   <PropertyGroup Label="ReactNativeWindowsProps">
     <ReactNativeWindowsDir Condition="'$(ReactNativeWindowsDir)' == ''">$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), 'node_modules\react-native-windows\package.json'))\node_modules\react-native-windows\</ReactNativeWindowsDir>
   </PropertyGroup>
 
+  <!-- 导入 RNW Windows SDK 默认配置（设置 WindowsTargetPlatformVersion） -->
+  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.WindowsSdk.Default.props" Condition="Exists('$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.WindowsSdk.Default.props')" />
+
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+
   <PropertyGroup Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <PlatformToolset>v143</PlatformToolset>
@@ -51,6 +81,11 @@
     <Import Project="PropertySheet.props" />
   </ImportGroup>
 
+  <!-- 导入 RNW UWP C++ Lib 配置（设置 TargetFrameworkMoniker、AssetTargetFallback、MIDL 引用等） -->
+  <ImportGroup Label="ReactNativeWindowsPropertySheets" Condition="'$(ReactNativeWindowsDir)' != ''">
+    <Import Project="$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.CppLib.props" />
+  </ImportGroup>
+
   <PropertyGroup Label="UserMacros" />
 
   <ItemDefinitionGroup>
@@ -66,6 +101,7 @@
       <AdditionalIncludeDirectories>$(ReactNativeWindowsDir);$(ReactNativeWindowsDir)Microsoft.ReactNative;$(ReactNativeWindowsDir)Microsoft.ReactNative.Cxx;$(ReactNativeWindowsDir)include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <LanguageStandard>stdcpp20</LanguageStandard>
       <PreprocessorDefinitions>NOMINMAX;WIN32_LEAN_AND_MEAN;SECURITY_WIN32;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalOptions>%(AdditionalOptions) /GS-</AdditionalOptions>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -88,6 +124,7 @@
     <ClCompile Include="SmtpProtocol.cpp" />
     <ClCompile Include="TlsSocket.cpp" />
     <ClCompile Include="ReactPackageProvider.cpp" />
+    <ClCompile Include="Generated Files\module.g.cpp" />
     <ClCompile Include="pch.cpp">
       <PrecompiledHeader>Create</PrecompiledHeader>
     </ClCompile>
@@ -109,22 +146,12 @@
     <Midl Include="ReactPackageProvider.idl" />
   </ItemGroup>
 
-  <!-- ═══════════════════════════════════════════════════════ -->
-  <!--  NuGet 引用                                           -->
-  <!-- ═══════════════════════════════════════════════════════ -->
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.ReactNative.WindowsSdk">
-      <Version>10.0.18362.0</Version>
-    </PackageReference>
-    <PackageReference Include="Microsoft.Windows.CppWinRT">
-      <Version>2.0.240111.5</Version>
-    </PackageReference>
-  </ItemGroup>
-
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
 
-  <!-- 导入 Microsoft.ReactNative 的 UWP CppLib targets -->
+  <!-- 导入 RNW UWP C++ Lib targets（自动添加 Microsoft.ReactNative、Microsoft.Windows.CppWinRT 等包引用） -->
+  <ImportGroup Label="ReactNativeWindowsTargets" Condition="'$(ReactNativeWindowsDir)' != ''">
+    <Import Project="$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.CppLib.targets" />
+  </ImportGroup>
   <ImportGroup Label="ReactNativeWindowsTargets">
     <Import Project="$(ReactNativeWindowsDir)\Microsoft.ReactNative.Cxx\Microsoft.ReactNative.Cxx.targets" Condition="Exists('$(ReactNativeWindowsDir)\Microsoft.ReactNative.Cxx\Microsoft.ReactNative.Cxx.targets')" />
     <Import Project="$(ReactNativeWindowsDir)\Microsoft.ReactNative\Microsoft.ReactNative.targets" Condition="Exists('$(ReactNativeWindowsDir)\Microsoft.ReactNative\Microsoft.ReactNative.targets')" />

package/windows/EmailImapSmtp/EmailImapSmtpModule.h

@@ -9,6 +9,9 @@
 #include <unordered_map>
 #include <memory>
 #include <mutex>
+#include <sstream>
+#include <optional>
+#include <thread>
 
 #include "winrt/Microsoft.ReactNative.h"
 #include "NativeModules.h"
@@ -18,6 +21,95 @@
 
 namespace winrt::EmailImapSmtp {
 
+// ─── JSON 序列化辅助 ────────────────────────────────────
+namespace detail {
+
+inline std::string escapeJson(const std::string& s) {
+  std::string out;
+  out.reserve(s.size() + 2);
+  for (char c : s) {
+    switch (c) {
+      case '"': out += "\\\""; break;
+      case '\\': out += "\\\\"; break;
+      case '\n': out += "\\n"; break;
+      case '\r': out += "\\r"; break;
+      case '\t': out += "\\t"; break;
+      default: out += c;
+    }
+  }
+  return out;
+}
+
+inline std::string toJson(const emailimap::MailboxInfo& mb) {
+  std::ostringstream os;
+  os << "{"
+     << "\"name\":\"" << escapeJson(mb.name) << "\","
+     << "\"path\":\"" << escapeJson(mb.path) << "\","
+     << "\"uidNext\":" << mb.uidNext << ","
+     << "\"uidValidity\":" << mb.uidValidity << ","
+     << "\"messageCount\":" << mb.messageCount << ","
+     << "\"recentCount\":" << mb.recentCount << ","
+     << "\"unseenCount\":" << mb.unseenCount << ","
+     << "\"firstUnseenUid\":" << mb.firstUnseenUid
+     << "}";
+  return os.str();
+}
+
+inline std::string toJson(const emailimap::MailboxListItem& item) {
+  std::ostringstream os;
+  os << "{"
+     << "\"name\":\"" << escapeJson(item.name) << "\","
+     << "\"path\":\"" << escapeJson(item.path) << "\","
+     << "\"subscribed\":" << (item.subscribed ? "true" : "false")
+     << "}";
+  return os.str();
+}
+
+inline std::string toJson(const emailimap::EmailAddress& addr) {
+  std::ostringstream os;
+  os << "{"
+     << "\"name\":\"" << escapeJson(addr.name) << "\","
+     << "\"email\":\"" << escapeJson(addr.email) << "\""
+     << "}";
+  return os.str();
+}
+
+inline std::string toJson(const emailimap::AttachmentInfo& att) {
+  std::ostringstream os;
+  os << "{"
+     << "\"filename\":\"" << escapeJson(att.filename) << "\","
+     << "\"mimeType\":\"" << escapeJson(att.mimeType) << "\","
+     << "\"partId\":\"" << escapeJson(att.partId) << "\","
+     << "\"size\":" << att.size
+     << "}";
+  return os.str();
+}
+
+inline std::string toJson(const emailimap::EmailMessage& msg) {
+  std::ostringstream os;
+  os << "{"
+     << "\"uid\":" << msg.uid << ","
+     << "\"subject\":\"" << escapeJson(msg.subject) << "\","
+     << "\"from\":" << toJson(msg.from) << ","
+     << "\"date\":\"" << escapeJson(msg.date) << "\","
+     << "\"size\":" << msg.size
+     << "}";
+  return os.str();
+}
+
+template<typename T, typename Fn>
+inline std::string arrayToJson(const std::vector<T>& items, Fn serializer) {
+  std::string result = "[";
+  for (size_t i = 0; i < items.size(); ++i) {
+    if (i > 0) result += ",";
+    result += serializer(items[i]);
+  }
+  result += "]";
+  return result;
+}
+
+} // namespace detail
+
 struct SessionState {
   std::unique_ptr<emailimap::ImapClient> imapClient;
   std::unique_ptr<emailimap::SmtpClient> smtpClient;
@@ -25,7 +117,7 @@ struct SessionState {
   bool smtpConnected = false;
 };
 
-REACT_MODULE(EmailImapSmtpModule, "EmailImapSmtp");
+REACT_MODULE(EmailImapSmtpModule, L"EmailImapSmtp");
 struct EmailImapSmtpModule {
   // ─── Session 管理 ─────────────────────────────────────
   std::unordered_map<std::string, std::shared_ptr<SessionState>> m_sessions;
@@ -54,85 +146,348 @@ struct EmailImapSmtpModule {
     m_sessions.erase(id);
   }
 
+  // ─── 异步辅助 ─────────────────────────────────────────
+  // 在后台线程执行网络操作，不阻塞 JS 线程
+  template<typename Fn>
+  void runAsync(React::ReactPromise<std::string> const& promise, Fn&& fn) noexcept {
+    std::thread([promise, fn = std::forward<Fn>(fn)]() {
+      try {
+        fn();
+      } catch (const std::exception& e) {
+        std::string err = detail::escapeJson(e.what());
+        promise.Resolve("{\"success\":false,\"error\":\"" + err + "\"}");
+      } catch (...) {
+        promise.Resolve("{\"success\":false,\"error\":\"Unknown error\"}");
+      }
+    }).detach();
+  }
+
   // ─── IMAP 连接 ────────────────────────────────────────
 
   REACT_METHOD(imapConnect);
-  std::string imapConnect(const std::string& configJson) noexcept {
-    try {
+  void imapConnect(std::string configJson, React::ReactPromise<std::string> promise) noexcept {
+    runAsync(promise, [this, configJson = std::move(configJson), promise]() {
       auto config = emailimap::ConnectionConfig{};
-      // TODO: parse configJson → config
-      // 使用 JSON 库（如 nlohmann/json）解析
+      auto extractStr = [](const std::string& json, const std::string& key) -> std::string {
+        std::string search = "\"" + key + "\":\"";
+        size_t pos = json.find(search);
+        if (pos == std::string::npos) return "";
+        pos += search.size();
+        size_t end = json.find("\"", pos);
+        if (end == std::string::npos) return "";
+        return json.substr(pos, end - pos);
+      };
+      auto extractDbl = [](const std::string& json, const std::string& key, double def) -> double {
+        std::string search = "\"" + key + "\":";
+        size_t pos = json.find(search);
+        if (pos == std::string::npos) return def;
+        pos += search.size();
+        size_t end = json.find_first_of(",}", pos);
+        if (end == std::string::npos) return def;
+        try { return std::stod(json.substr(pos, end - pos)); }
+        catch (...) { return def; }
+      };
+      auto extractBool = [](const std::string& json, const std::string& key, bool def) -> bool {
+        std::string search = "\"" + key + "\":true";
+        if (json.find(search) != std::string::npos) return true;
+        search = "\"" + key + "\":false";
+        if (json.find(search) != std::string::npos) return false;
+        return def;
+      };
+      config.host = extractStr(configJson, "host");
+      config.port = extractDbl(configJson, "port", 993);
+      config.username = extractStr(configJson, "username");
+      config.password = extractStr(configJson, "password");
+      config.tls = extractBool(configJson, "tls", true);
+      config.authType = extractStr(configJson, "authType");
+      if (config.authType.empty()) config.authType = "password";
+      config.timeout = extractDbl(configJson, "timeout", 30000);
+      config.checkCertificate = extractBool(configJson, "checkCertificate", true);
+      config.debug = extractBool(configJson, "debug", false);
 
       auto sessionId = createSession();
       auto session = getSession(sessionId);
       std::string error;
       if (session->imapClient->connect(config, error)) {
         session->imapConnected = true;
-        return "{\"success\":true,\"sessionId\":\"" + sessionId + "\"}";
+        promise.Resolve("{\"success\":true,\"sessionId\":\"" + sessionId + "\"}");
+        return;
       }
       removeSession(sessionId);
-      return "{\"success\":false,\"error\":\"" + escapeJson(error) + "\"}";
-    } catch (const std::exception& e) {
-      return "{\"success\":false,\"error\":\"" + escapeJson(e.what()) + "\"}";
-    }
+      promise.Resolve("{\"success\":false,\"error\":\"" + detail::escapeJson(error) + "\"}");
+    });
   }
 
   REACT_METHOD(imapDisconnect);
-  void imapDisconnect(const std::string& sessionId) noexcept {
-    auto session = getSession(sessionId);
-    if (session && session->imapConnected) {
-      session->imapClient->disconnect();
-      session->imapConnected = false;
-    }
-    removeSession(sessionId);
+  void imapDisconnect(std::string sessionId, React::ReactPromise<std::string> promise) noexcept {
+    runAsync(promise, [this, sessionId = std::move(sessionId), promise]() {
+      auto session = getSession(sessionId);
+      if (session && session->imapConnected) {
+        session->imapClient->disconnect();
+        session->imapConnected = false;
+      }
+      removeSession(sessionId);
+      promise.Resolve("{\"success\":true}");
+    });
+  }
+
+  // ─── IMAP 其他方法 ──────────────────────────────────
+
+  REACT_METHOD(imapListMailboxes);
+  void imapListMailboxes(std::string sessionId, React::ReactPromise<std::string> promise) noexcept {
+    runAsync(promise, [this, sessionId = std::move(sessionId), promise]() {
+      auto session = getSession(sessionId);
+      if (!session || !session->imapConnected) {
+        promise.Resolve("{\"success\":false,\"error\":\"Not connected\"}");
+        return;
+      }
+      std::string error;
+      auto mailboxes = session->imapClient->listMailboxes(error);
+      if (!error.empty()) {
+        promise.Resolve("{\"success\":false,\"error\":\"" + detail::escapeJson(error) + "\"}");
+        return;
+      }
+      promise.Resolve("{\"success\":true,\"mailboxes\":" +
+             detail::arrayToJson(mailboxes, [](const emailimap::MailboxListItem& i) { return detail::toJson(i); }) + "}");
+    });
+  }
+
+  REACT_METHOD(imapSelectMailbox);
+  void imapSelectMailbox(std::string sessionId, std::string mailbox, bool readOnly, React::ReactPromise<std::string> promise) noexcept {
+    runAsync(promise, [this, sessionId = std::move(sessionId), mailbox = std::move(mailbox), readOnly, promise]() {
+      auto session = getSession(sessionId);
+      if (!session || !session->imapConnected) {
+        promise.Resolve("{\"success\":false,\"error\":\"Not connected\"}");
+        return;
+      }
+      std::string error;
+      auto info = session->imapClient->selectMailbox(mailbox, readOnly, error);
+      if (!error.empty()) {
+        promise.Resolve("{\"success\":false,\"error\":\"" + detail::escapeJson(error) + "\"}");
+        return;
+      }
+      promise.Resolve("{\"success\":true,\"mailbox\":" + detail::toJson(info) + "}");
+    });
+  }
+
+  REACT_METHOD(imapFetchEmails);
+  void imapFetchEmails(std::string sessionId, std::string optionsJson, React::ReactPromise<std::string> promise) noexcept {
+    runAsync(promise, [this, sessionId = std::move(sessionId), optionsJson = std::move(optionsJson), promise]() {
+      auto session = getSession(sessionId);
+      if (!session || !session->imapConnected) {
+        promise.Resolve("{\"success\":false,\"error\":\"Not connected\"}");
+        return;
+      }
+      emailimap::FetchEmailsOptions opts;
+      auto extractDouble = [](const std::string& json, const std::string& key) -> std::optional<double> {
+        std::string search = "\"" + key + "\":";
+        size_t pos = json.find(search);
+        if (pos == std::string::npos) return std::nullopt;
+        pos += search.size();
+        size_t end = json.find_first_of(",}", pos);
+        if (end == std::string::npos) return std::nullopt;
+        std::string val = json.substr(pos, end - pos);
+        size_t start = val.find_first_not_of(" \t\r\n\"");
+        size_t finish = val.find_last_not_of(" \t\r\n\"");
+        if (start == std::string::npos) return std::nullopt;
+        val = val.substr(start, finish - start + 1);
+        try { return std::stod(val); }
+        catch (...) { return std::nullopt; }
+      };
+      auto extractString = [](const std::string& json, const std::string& key) -> std::optional<std::string> {
+        std::string search = "\"" + key + "\":\"";
+        size_t pos = json.find(search);
+        if (pos == std::string::npos) return std::nullopt;
+        pos += search.size();
+        size_t end = json.find("\"", pos);
+        if (end == std::string::npos) return std::nullopt;
+        return json.substr(pos, end - pos);
+      };
+      auto extractBool = [](const std::string& json, const std::string& key) -> bool {
+        std::string search = "\"" + key + "\":true";
+        return json.find(search) != std::string::npos;
+      };
+      auto page = extractDouble(optionsJson, "page");
+      auto pageSize = extractDouble(optionsJson, "pageSize");
+      auto from = extractDouble(optionsJson, "from");
+      auto to = extractDouble(optionsJson, "to");
+      if (page.has_value()) opts.page = page.value();
+      if (pageSize.has_value()) opts.pageSize = pageSize.value();
+      if (from.has_value()) opts.from = from.value();
+      if (to.has_value()) opts.to = to.value();
+      opts.fetchBody = extractBool(optionsJson, "fetchBody");
+      opts.fetchAttachments = extractBool(optionsJson, "fetchAttachments");
+      opts.fetchFlags = extractBool(optionsJson, "fetchFlags");
+      opts.fetchHeaders = extractBool(optionsJson, "fetchHeaders");
+      auto since = extractString(optionsJson, "since");
+      auto before = extractString(optionsJson, "before");
+      if (since.has_value()) opts.since = since.value();
+      if (before.has_value()) opts.before = before.value();
+      std::string error;
+      auto emails = session->imapClient->fetchEmails(opts, error);
+      if (!error.empty()) {
+        promise.Resolve("{\"success\":false,\"error\":\"" + detail::escapeJson(error) + "\"}");
+        return;
+      }
+      promise.Resolve("{\"success\":true,\"emails\":" +
+             detail::arrayToJson(emails, [](const emailimap::EmailMessage& e) { return detail::toJson(e); }) + "}");
+    });
+  }
+
+  REACT_METHOD(imapFetchEmailByUID);
+  void imapFetchEmailByUID(std::string sessionId, double uid, React::ReactPromise<std::string> promise) noexcept {
+    runAsync(promise, [this, sessionId = std::move(sessionId), uid, promise]() {
+      auto session = getSession(sessionId);
+      if (!session || !session->imapConnected) {
+        promise.Resolve("{\"success\":false,\"error\":\"Not connected\"}");
+        return;
+      }
+      std::string error;
+      auto* msg = session->imapClient->fetchEmailByUID(uid, error);
+      if (!msg) {
+        promise.Resolve("{\"success\":false,\"error\":\"" + detail::escapeJson(error) + "\"}");
+        return;
+      }
+      promise.Resolve("{\"success\":true,\"email\":" + detail::toJson(*msg) + "}");
+      delete msg;
+    });
+  }
+
+  REACT_METHOD(imapSearchEmails);
+  void imapSearchEmails(std::string sessionId, std::string criteriaJson, React::ReactPromise<std::string> promise) noexcept {
+    runAsync(promise, [this, sessionId = std::move(sessionId), criteriaJson = std::move(criteriaJson), promise]() {
+      auto session = getSession(sessionId);
+      if (!session || !session->imapConnected) {
+        promise.Resolve("{\"success\":false,\"error\":\"Not connected\"}");
+        return;
+      }
+      emailimap::SearchCriteria criteria;
+      auto extractStr = [](const std::string& json, const std::string& key) -> std::optional<std::string> {
+        std::string search = "\"" + key + "\":\"";
+        size_t pos = json.find(search);
+        if (pos == std::string::npos) return std::nullopt;
+        pos += search.size();
+        size_t end = json.find("\"", pos);
+        if (end == std::string::npos) return std::nullopt;
+        return json.substr(pos, end - pos);
+      };
+      auto extractBool = [](const std::string& json, const std::string& key) -> bool {
+        return json.find("\"" + key + "\":true") != std::string::npos;
+      };
+      auto subject = extractStr(criteriaJson, "subject");
+      auto from = extractStr(criteriaJson, "from");
+      auto to = extractStr(criteriaJson, "to");
+      auto text = extractStr(criteriaJson, "text");
+      auto body = extractStr(criteriaJson, "body");
+      auto since = extractStr(criteriaJson, "since");
+      auto before = extractStr(criteriaJson, "before");
+      if (subject.has_value()) criteria.subject = subject.value();
+      if (from.has_value()) criteria.from = from.value();
+      if (to.has_value()) criteria.to = to.value();
+      if (text.has_value()) criteria.text = text.value();
+      if (body.has_value()) criteria.body = body.value();
+      if (since.has_value()) criteria.since = since.value();
+      if (before.has_value()) criteria.before = before.value();
+      criteria.flagged = extractBool(criteriaJson, "flagged");
+      criteria.seen = extractBool(criteriaJson, "seen");
+      std::string error;
+      auto emails = session->imapClient->searchEmails(criteria, error);
+      if (!error.empty()) {
+        promise.Resolve("{\"success\":false,\"error\":\"" + detail::escapeJson(error) + "\"}");
+        return;
+      }
+      promise.Resolve("{\"success\":true,\"emails\":" +
+             detail::arrayToJson(emails, [](const emailimap::EmailMessage& e) { return detail::toJson(e); }) + "}");
+    });
   }
 
   // ─── SMTP ──────────────────────────────────────────────
 
   REACT_METHOD(smtpConnect);
-  std::string smtpConnect(const std::string& configJson) noexcept {
-    try {
+  void smtpConnect(std::string configJson, React::ReactPromise<std::string> promise) noexcept {
+    runAsync(promise, [this, configJson = std::move(configJson), promise]() {
       auto config = emailimap::SmtpConnectionConfig{};
-      // TODO: parse configJson → config
+      auto extractStr = [](const std::string& json, const std::string& key) -> std::string {
+        std::string search = "\"" + key + "\":\"";
+        size_t pos = json.find(search);
+        if (pos == std::string::npos) return "";
+        pos += search.size();
+        size_t end = json.find("\"", pos);
+        if (end == std::string::npos) return "";
+        return json.substr(pos, end - pos);
+      };
+      auto extractDbl = [](const std::string& json, const std::string& key, double def) -> double {
+        std::string search = "\"" + key + "\":";
+        size_t pos = json.find(search);
+        if (pos == std::string::npos) return def;
+        pos += search.size();
+        size_t end = json.find_first_of(",}", pos);
+        if (end == std::string::npos) return def;
+        try { return std::stod(json.substr(pos, end - pos)); }
+        catch (...) { return def; }
+      };
+      auto extractBool = [](const std::string& json, const std::string& key, bool def) -> bool {
+        std::string search = "\"" + key + "\":true";
+        if (json.find(search) != std::string::npos) return true;
+        search = "\"" + key + "\":false";
+        if (json.find(search) != std::string::npos) return false;
+        return def;
+      };
+      config.host = extractStr(configJson, "host");
+      config.port = extractDbl(configJson, "port", 465);
+      config.username = extractStr(configJson, "username");
+      config.password = extractStr(configJson, "password");
+      config.tls = extractBool(configJson, "tls", true);
+      config.authType = extractStr(configJson, "authType");
+      if (config.authType.empty()) config.authType = "password";
+      config.timeout = extractDbl(configJson, "timeout", 30000);
+      config.checkCertificate = extractBool(configJson, "checkCertificate", true);
+      config.debug = extractBool(configJson, "debug", false);
 
       auto sessionId = createSession();
       auto session = getSession(sessionId);
       std::string error;
       if (session->smtpClient->connect(config, error)) {
         session->smtpConnected = true;
-        return "{\"success\":true,\"sessionId\":\"" + sessionId + "\"}";
+        promise.Resolve("{\"success\":true,\"sessionId\":\"" + sessionId + "\"}");
+        return;
       }
       removeSession(sessionId);
-      return "{\"success\":false,\"error\":\"" + escapeJson(error) + "\"}";
-    } catch (const std::exception& e) {
-      return "{\"success\":false,\"error\":\"" + escapeJson(e.what()) + "\"}";
-    }
+      promise.Resolve("{\"success\":false,\"error\":\"" + detail::escapeJson(error) + "\"}");
+    });
   }
 
   REACT_METHOD(smtpDisconnect);
-  void smtpDisconnect(const std::string& sessionId) noexcept {
-    auto session = getSession(sessionId);
-    if (session && session->smtpConnected) {
-      session->smtpClient->disconnect();
-      session->smtpConnected = false;
-    }
-    removeSession(sessionId);
+  void smtpDisconnect(std::string sessionId, React::ReactPromise<std::string> promise) noexcept {
+    runAsync(promise, [this, sessionId = std::move(sessionId), promise]() {
+      auto session = getSession(sessionId);
+      if (session && session->smtpConnected) {
+        session->smtpClient->disconnect();
+        session->smtpConnected = false;
+      }
+      removeSession(sessionId);
+      promise.Resolve("{\"success\":true}");
+    });
   }
 
-private:
-  static std::string escapeJson(const std::string& s) {
-    std::string result;
-    for (char c : s) {
-      switch (c) {
-        case '"': result += "\\\""; break;
-        case '\\': result += "\\\\"; break;
-        case '\n': result += "\\n"; break;
-        case '\r': result += "\\r"; break;
-        case '\t': result += "\\t"; break;
-        default: result += c;
+  REACT_METHOD(smtpSendMail);
+  void smtpSendMail(std::string sessionId, std::string mailJson, React::ReactPromise<std::string> promise) noexcept {
+    runAsync(promise, [this, sessionId = std::move(sessionId), mailJson = std::move(mailJson), promise]() {
+      auto session = getSession(sessionId);
+      if (!session || !session->smtpConnected) {
+        promise.Resolve("{\"success\":false,\"error\":\"SMTP not connected\"}");
+        return;
       }
-    }
-    return result;
+      emailimap::SendMailOptions opts;
+      emailimap::SendMailResult result;
+      // TODO: parse mailJson → opts
+      std::string error;
+      if (session->smtpClient->sendMail(opts, result, error)) {
+        promise.Resolve("{\"success\":true}");
+        return;
+      }
+      promise.Resolve("{\"success\":false,\"error\":\"" + detail::escapeJson(error) + "\"}");
+    });
   }
 };
 

package/windows/EmailImapSmtp/ReactPackageProvider.idl

@@ -4,11 +4,10 @@
 
 namespace EmailImapSmtp
 {
-    [webhosthidden]
     [default_interface]
     runtimeclass ReactPackageProvider : Microsoft.ReactNative.IReactPackageProvider
     {
         ReactPackageProvider();
     };
 }
-}
+

package/windows/EmailImapSmtp/TlsSocket.cpp

@@ -5,6 +5,129 @@
 #include "pch.h"
 #include "TlsSocket.h"
 
+// Manual SSPI/Schannel declarations for UWP compat (SDK excludes these)
+#pragma comment(lib, "ws2_32.lib")
+#pragma comment(lib, "crypt32.lib")
+#pragma comment(lib, "secur32.lib")
+
+#ifndef SCHANNEL_CRED_VERSION
+#define SECURITY_STATUS int
+#define SEC_E_OK 0
+#define SEC_I_CONTINUE_NEEDED 0x00090312L
+#define SEC_E_INCOMPLETE_MESSAGE 0x80090318L
+#define SECPKG_ATTR_STREAM_SIZES 0x00000004
+#define SECPKG_CRED_OUTBOUND 2
+#define SCHANNEL_CRED_VERSION 4
+#define SP_PROT_TLS1_2 0x00000800
+#define SCH_CRED_MANUAL_CRED_VALIDATION 0x00000008
+#define SCH_CRED_NO_SYSTEM_MAPPER 0x00000002
+#define SCH_CRED_NO_SERVERNAME_CHECK 0x00000004
+#define SECBUFFER_VERSION 0
+#define SECBUFFER_EMPTY 0
+#define SECBUFFER_DATA 1
+#define SECBUFFER_TOKEN 2
+#define SECBUFFER_STREAM_HEADER 5
+#define SECBUFFER_STREAM_TRAILER 6
+#define SECBUFFER_EXTRA 9
+#define SECBUFFER_MISSING 11
+#define ISC_REQ_SEQUENCE_DETECT 0x00000008
+#define ISC_REQ_REPLAY_DETECT 0x00000004
+#define ISC_REQ_CONFIDENTIALITY 0x00000010
+#define ISC_REQ_ALLOCATE_MEMORY 0x00000100
+#define ISC_REQ_STREAM 0x00008000
+#define ISC_REQ_MANUAL_CRED_VALIDATION 0x00080000
+
+typedef struct _SecHandle {
+  ULONG_PTR dwLower;
+  ULONG_PTR dwUpper;
+} SecHandle;
+typedef SecHandle CredHandle;
+typedef SecHandle CtxtHandle;
+
+typedef struct _SecBuffer {
+  unsigned long cbBuffer;
+  unsigned long BufferType;
+  void* pvBuffer;
+} SecBuffer;
+
+typedef struct _SecBufferDesc {
+  unsigned long ulVersion;
+  unsigned long cBuffers;
+  SecBuffer* pBuffers;
+} SecBufferDesc;
+
+typedef struct _SCHANNEL_CRED {
+  DWORD dwVersion;
+  DWORD cCreds;
+  void* paCred;
+  void* hRootStore;
+  DWORD cMappers;
+  void* aphMappers;
+  DWORD cSupportedAlgs;
+  void* paSupportedAlgs;
+  DWORD dwFlags;
+  DWORD dwCredFormat;
+  DWORD grbitEnabledProtocols;
+  DWORD dwMinimumCipherStrength;
+  DWORD dwMaximumCipherStrength;
+} SCHANNEL_CRED;
+
+typedef struct _SecPkgContext_StreamSizes {
+  unsigned long cbHeader;
+  unsigned long cbTrailer;
+  unsigned long cbMaximumMessage;
+  unsigned long cBuffers;
+  unsigned long cbBlockSize;
+  unsigned long cbMaxTrailer;
+} SecPkgContext_StreamSizes;
+
+typedef struct _SecPkgContext_Sizes {
+  unsigned long cbMaxToken;
+  unsigned long cbMaxSignature;
+  unsigned long cbBlockSize;
+  unsigned long cbMaxTrailer;
+} SecPkgContext_Sizes;
+
+typedef struct _TimeStamp {
+  LONG LowPart;
+  LONG HighPart;
+} TimeStamp;
+
+#ifndef SEC_ENTRY
+#define SEC_ENTRY
+#endif
+extern "C" {
+int SEC_ENTRY AcquireCredentialsHandleW(LPWSTR, LPWSTR, unsigned long, void*, void*, void*, void*, CredHandle*, TimeStamp*);
+int SEC_ENTRY AcquireCredentialsHandleA(LPSTR, LPSTR, unsigned long, void*, void*, void*, void*, CredHandle*, TimeStamp*);
+int SEC_ENTRY InitializeSecurityContextA(CredHandle*, void*, LPSTR, unsigned long, unsigned long, unsigned long, SecBufferDesc*, unsigned long, CtxtHandle*, SecBufferDesc*, unsigned long*, TimeStamp*);
+int SEC_ENTRY InitializeSecurityContextW(CredHandle*, void*, LPWSTR, unsigned long, unsigned long, unsigned long, SecBufferDesc*, unsigned long, CtxtHandle*, SecBufferDesc*, unsigned long*, TimeStamp*);
+int SEC_ENTRY DeleteSecurityContext(CtxtHandle*);
+int SEC_ENTRY FreeCredentialsHandle(CredHandle*);
+int SEC_ENTRY FreeContextBuffer(void*);
+int SEC_ENTRY EncryptMessage(CtxtHandle*, unsigned long, SecBufferDesc*, unsigned long);
+int SEC_ENTRY DecryptMessage(CtxtHandle*, SecBufferDesc*, unsigned long, void*);
+int SEC_ENTRY QueryContextAttributesW(CtxtHandle*, unsigned long, void*);
+int SEC_ENTRY QueryContextAttributesA(CtxtHandle*, unsigned long, void*);
+}
+
+#define UNISP_NAME_A "Microsoft Unified Security Protocol Provider"
+#define UNISP_NAME UNISP_NAME_A
+#define AcquireCredentialsHandle AcquireCredentialsHandleA
+#define QueryContextAttributes QueryContextAttributesA
+
+#endif // SCHANNEL_CRED_VERSION
+
+// Cast helpers: uint8_t[] members -> typed references for SSPI API calls
+#ifdef SCHANNEL_CRED_VERSION
+#define credHandle (*reinterpret_cast<CredHandle*>(m_credHandle))
+#define ctxtHandle (*reinterpret_cast<CtxtHandle*>(m_ctxtHandle))
+#define streamSizes (*reinterpret_cast<SecPkgContext_StreamSizes*>(m_streamSizes))
+#else
+#define credHandle m_credHandle
+#define ctxtHandle m_ctxtHandle
+#define streamSizes m_streamSizes
+#endif
+
 #include <sstream>
 #include <cstring>
 #include <chrono>
@@ -250,11 +373,11 @@ bool TlsSocket::connect(const std::string& host, int port, int timeoutMs, bool c
 
 void TlsSocket::disconnectInternal() {
   if (m_hasCtxtHandle) {
-    DeleteSecurityContext(&m_ctxtHandle);
+    DeleteSecurityContext(&ctxtHandle);
     m_hasCtxtHandle = false;
   }
   if (m_hasCredHandle) {
-    FreeCredentialsHandle(&m_credHandle);
+    FreeCredentialsHandle(&credHandle);
     m_hasCredHandle = false;
   }
   if (m_socket != INVALID_SOCKET) {
@@ -299,7 +422,7 @@ bool TlsSocket::initializeSchannel() {
     &schannelCred,
     nullptr,
     nullptr,
-    &m_credHandle,
+    &credHandle,
     &expiry
   );
 
@@ -338,7 +461,7 @@ bool TlsSocket::performClientHandshake() {
   TimeStamp expiry;
 
   status = InitializeSecurityContextW(
-    &m_credHandle,
+    &credHandle,
     nullptr,
     const_cast<wchar_t*>(wServerName.c_str()),
     flags,
@@ -346,7 +469,7 @@ bool TlsSocket::performClientHandshake() {
     0,
     nullptr,
     0,
-    &m_ctxtHandle,
+    &ctxtHandle,
     &outDesc,
     &outFlags,
     &expiry
@@ -405,8 +528,8 @@ bool TlsSocket::performClientHandshake() {
     outBuffers[0].BufferType = SECBUFFER_TOKEN;
 
     status = InitializeSecurityContextW(
-      &m_credHandle,
-      &m_ctxtHandle,
+      &credHandle,
+      &ctxtHandle,
       const_cast<wchar_t*>(wServerName.c_str()),
       flags,
       0,
@@ -478,7 +601,7 @@ bool TlsSocket::performClientHandshake() {
     }
 
     if (status == SEC_E_OK) {
-      QueryContextAttributes(&m_ctxtHandle, SECPKG_ATTR_STREAM_SIZES, &m_streamSizes);
+      QueryContextAttributes(&ctxtHandle, SECPKG_ATTR_STREAM_SIZES, &streamSizes);
       m_hasCtxtHandle = true;
       // Save any extra (unconsumed) data to m_receiveBuffer so the caller
       // can read it (e.g. IMAP greeting piggybacked on the handshake).
@@ -506,22 +629,22 @@ bool TlsSocket::performClientHandshake() {
 bool TlsSocket::encryptMessage(const std::string& plaintext, std::vector<char>& ciphertext) {
   if (!m_hasCtxtHandle) return false;
 
-  int needed = m_streamSizes.cbHeader + static_cast<int>(plaintext.size()) + m_streamSizes.cbTrailer;
+  int needed = streamSizes.cbHeader + static_cast<int>(plaintext.size()) + streamSizes.cbTrailer;
   std::vector<char> msg(needed);
 
   SecBuffer buffers[4];
-  buffers[0].cbBuffer = m_streamSizes.cbHeader;
+  buffers[0].cbBuffer = streamSizes.cbHeader;
   buffers[0].BufferType = SECBUFFER_STREAM_HEADER;
   buffers[0].pvBuffer = msg.data();
 
   buffers[1].cbBuffer = static_cast<unsigned long>(plaintext.size());
   buffers[1].BufferType = SECBUFFER_DATA;
-  buffers[1].pvBuffer = msg.data() + m_streamSizes.cbHeader;
+  buffers[1].pvBuffer = msg.data() + streamSizes.cbHeader;
   memcpy(buffers[1].pvBuffer, plaintext.data(), plaintext.size());
 
-  buffers[2].cbBuffer = m_streamSizes.cbTrailer;
+  buffers[2].cbBuffer = streamSizes.cbTrailer;
   buffers[2].BufferType = SECBUFFER_STREAM_TRAILER;
-  buffers[2].pvBuffer = msg.data() + m_streamSizes.cbHeader + plaintext.size();
+  buffers[2].pvBuffer = msg.data() + streamSizes.cbHeader + plaintext.size();
 
   buffers[3].cbBuffer = 0;
   buffers[3].BufferType = SECBUFFER_EMPTY;
@@ -531,7 +654,7 @@ bool TlsSocket::encryptMessage(const std::string& plaintext, std::vector<char>&
   desc.cBuffers = 4;
   desc.pBuffers = buffers;
 
-  SECURITY_STATUS status = EncryptMessage(&m_ctxtHandle, 0, &desc, 0);
+  SECURITY_STATUS status = EncryptMessage(&ctxtHandle, 0, &desc, 0);
   if (status != SEC_E_OK) return false;
 
   int totalSize = buffers[0].cbBuffer + buffers[1].cbBuffer + buffers[2].cbBuffer;
@@ -564,7 +687,7 @@ int TlsSocket::decryptMessage(std::vector<char>& buffer, std::vector<char>& plai
   desc.cBuffers = 4;
   desc.pBuffers = buffers;
 
-  SECURITY_STATUS status = DecryptMessage(&m_ctxtHandle, &desc, 0, nullptr);
+  SECURITY_STATUS status = DecryptMessage(&ctxtHandle, &desc, 0, nullptr);
   if (status == SEC_E_INCOMPLETE_MESSAGE) {
     // need more data
     return 0; // need more data

package/windows/EmailImapSmtp/TlsSocket.h

@@ -58,13 +58,13 @@ public:
 private:
   SOCKET m_socket = INVALID_SOCKET;
   bool m_tls = false;
-  CredHandle m_credHandle{};
-  CtxtHandle m_ctxtHandle{};
+  uint8_t m_credHandle[16];
+  uint8_t m_ctxtHandle[16];
   bool m_hasCredHandle = false;
   bool m_hasCtxtHandle = false;
   std::string m_serverName;
   bool m_checkCertificate = true;
-  SecPkgContext_StreamSizes m_streamSizes{};
+  uint8_t m_streamSizes[24];
 
   std::mutex m_mutex;
   int m_lastError = 0; // stores WSAGetLastError() on failure

package/windows/ExperimentalFeatures.props

@@ -6,7 +6,9 @@
     <!-- 不使用 WinUI 3 -->
     <UseWinUI3>false</UseWinUI3>
     <!-- 不使用实验性 NuGet -->
-    <UseExperimentalNuget>false</UseExperimentalNuget>
+    <UseExperimentalNuget>true</UseExperimentalNuget>
+    <RnwNewArch>true</RnwNewArch>
+    <RunCodegenWindows>false</RunCodegenWindows>
     <!-- 不使用 Folly (不再需要) -->
     <UseFolly>false</UseFolly>
   </PropertyGroup>