@amazon-devices/expo-file-system 2.0.9000000000 → 3.0.0

package/kepler/ExponentFileSystem.cpp

@@ -9,18 +9,26 @@
 #include "ExponentFileSystem.h"
 
 #include <JsonContainer/JsonContainer.h>
-#include <KeplerScript/logger/KPLog.h>
-#include <KeplerScript/utils/KeplerPath.h>
+#include <Kepler/turbomodule/TMLog.h>
 #include <openssl/evp.h>
 #include <openssl/md5.h>
 #include <sys/stat.h>
 
+#include <algorithm>
 #include <filesystem>
 #include <fstream>
 #include <iostream>
 #include <memory>
 #include <sstream>
 #include <string>
+#include <thread>
+
+#include "CurlWrapper.h"
+
+using com::amazon::kepler::turbomodule::ArrayBuffer;
+using com::amazon::kepler::turbomodule::NativeJSArray;
+using com::amazon::kepler::turbomodule::NativeJSObject;
+using com::amazon::kepler::turbomodule::Promise;
 
 namespace {
 std::string md5Hash(const std::string& content) {
@@ -54,7 +62,7 @@ std::string base64Encode(const std::string& input) {
 }
 
 template<typename T>
-T getOrDefault(volta::react::NativeJSObject map, std::string key, const T& defaultValue) {
+T getOrDefault(NativeJSObject map, std::string key, const T& defaultValue) {
     if (map.count(key)) {
         return std::get<T>(map[key]);
     }
@@ -62,8 +70,9 @@ T getOrDefault(volta::react::NativeJSObject map, std::string key, const T& defau
 }
 }  // namespace
 
-ExponentFileSystem::ExponentFileSystem() : volta::react::KeplerTurboModule("ExponentFileSystem") {
-    volta::react::KPLog.debug("ExponentFileSystem constructor {}", name());
+ExponentFileSystem::ExponentFileSystem() : com::amazon::kepler::turbomodule::KeplerTurboModule("ExponentFileSystem") {
+    TMDEBUG(std::string("ExponentFileSystem constructor ") + name());
+    curlWrapper_ = std::make_unique<CurlWrapper>();
 };
 
 /**
@@ -79,21 +88,19 @@ std::string ExponentFileSystem::cacheDirectory() {
 };
 
 std::string ExponentFileSystem::bundleDirectory() {
-    return volta::react::KeplerPath::getPath(volta::react::KeplerPathKind::JavaScriptBundle);
+    const std::string bundleName = "index.hermes.bundle";
+    return std::filesystem::absolute("pkg/bundle/" + bundleName);
 };
 
-volta::react::Promise ExponentFileSystem::getInfoAsync(
-        const std::string fileUri,
-        volta::react::NativeJSObject options) {
+Promise ExponentFileSystem::getInfoAsync(const std::string fileUri, NativeJSObject options) {
     bool shouldIncludeFileSize = getOrDefault(options, "size", false);
     bool shouldIncludeMD5Hash = getOrDefault(options, "md5", false);
 
-    return volta::react::Promise([this, fileUri, shouldIncludeFileSize, shouldIncludeMD5Hash](
-                                         std::shared_ptr<volta::react::Promise> promise) {
+    return Promise([this, fileUri, shouldIncludeFileSize, shouldIncludeMD5Hash](std::shared_ptr<Promise> promise) {
         bool exists = std::filesystem::exists(fileUri);
 
         if (!exists) {
-            promise->resolve(volta::react::NativeJSObject{{"exists", false}, {"isDirectory", false}});
+            promise->resolve(NativeJSObject{{"exists", false}, {"isDirectory", false}});
             return;
         }
 
@@ -102,15 +109,18 @@ volta::react::Promise ExponentFileSystem::getInfoAsync(
         struct stat fileStat;
         int status = stat(fileUri.c_str(), &fileStat);
         if (status != 0) {
-            volta::react::KPLog.error("[ExponentFileSystem] error while obtaining information about the file!");
-            promise->reject("Error while obtaining information about the file!");
+            std::string errorMessage = std::strerror(errno);
+            TMERROR(std::string("[ExponentFileSystem] error in `stat()` call: ") + errorMessage + " while obtaining information about the file: " + fileUri + "!");
+            promise->reject(
+                    "Error while obtaining information about the file! `stat()` call exited with error: " +
+                    errorMessage);
             return;
         }
 
         std::uintmax_t modificationTime = fileStat.st_mtime;
         std::uintmax_t fileSize = getSize(fileUri);
 
-        auto fileInfo = volta::react::NativeJSObject{
+        auto fileInfo = NativeJSObject{
                 {"exists", true},
                 {"isDirectory", isDirectory},
                 {"modification", std::to_string(modificationTime)}};
@@ -121,19 +131,20 @@ volta::react::Promise ExponentFileSystem::getInfoAsync(
 
         if (shouldIncludeMD5Hash) {
             std::ifstream stream(fileUri);
-            volta::react::KPLog.debug("[MD5] trying to open the file: {} for read", fileUri);
+            TMDEBUG(std::string("[MD5] trying to open the file: ") + fileUri + " for read");
             if (stream.fail()) {
-                volta::react::KPLog.error("[MD5] unable to open file at {} for read", fileUri);
-                promise->reject("Error while trying to open the file");
+                std::string errorMessage = std::strerror(errno);
+                TMERROR(std::string("[MD5] unable to open file at ") + fileUri + " for read: " + errorMessage);
+                promise->reject("Error while trying to open the file: " + errorMessage);
                 return;
             } else {
                 std::stringstream buffer;
                 buffer << stream.rdbuf();
                 std::string content = buffer.str();
-                volta::react::KPLog.debug("[MD5] content: {}", content);
-                volta::react::KPLog.debug("[MD5] calculating the file content hash...");
+                TMDEBUG(std::string("[MD5] content: ") + content);
+                TMDEBUG("[MD5] calculating the file content hash...");
                 std::string hash = md5Hash(content);
-                volta::react::KPLog.debug("[MD5] file hash: {}", hash);
+                TMDEBUG(std::string("[MD5] file hash: ") + hash);
                 fileInfo.insert({"md5", hash});
             }
         }
@@ -141,140 +152,140 @@ volta::react::Promise ExponentFileSystem::getInfoAsync(
     });
 };
 
-volta::react::Promise ExponentFileSystem::readAsStringAsync(
-        const std::string fileUri,
-        volta::react::NativeJSObject options) {
+Promise ExponentFileSystem::readAsStringAsync(const std::string fileUri, NativeJSObject options) {
     std::string desiredEncoding = getOrDefault(options, "encoding", std::string("utf8"));
     int bytesToSkip = int(getOrDefault(options, "position", static_cast<double>(0)));
     int length = getOrDefault(options, "length", static_cast<double>(-1));
 
-    return volta::react::Promise(
-            [this, fileUri, desiredEncoding, bytesToSkip, length](std::shared_ptr<volta::react::Promise> promise) {
-                try {
-                    volta::react::KPLog.debug("[ExponentFileSystem] path: {}", fileUri);
-                    std::int32_t fileSize = std::filesystem::file_size(fileUri);
-
-                    std::ifstream stream(fileUri);
-                    volta::react::KPLog.debug("[ExponentFileSystem] trying to open the file: {} for read", fileUri);
-                    if (stream.fail()) {
-                        volta::react::KPLog.error("[ExponentFileSystem] unable to open file at {} for read", fileUri);
-                        promise->reject("Error while trying to open the file");
-                        return;
-                    }
+    return Promise([this, fileUri, desiredEncoding, bytesToSkip, length](std::shared_ptr<Promise> promise) {
+        try {
+            TMDEBUG(std::string("[ExponentFileSystem] path: ") + fileUri);
+            std::int32_t fileSize = std::filesystem::file_size(fileUri);
 
-                    if (bytesToSkip >= fileSize) {
-                        volta::react::KPLog.error("[ExponentFileSystem] cannot skip beyond end of file!");
-                        promise->reject("Cannot skip beyond end of file");
-                        return;
-                    }
+            std::ifstream stream(fileUri);
+            TMDEBUG(std::string("[ExponentFileSystem] trying to open the file: ") + fileUri + " for read");
+            if (stream.fail()) {
+                std::string errorMessage = std::strerror(errno);
+                TMERROR(std::string("[ExponentFileSystem] unable to open file at ") + fileUri + " for read: " + errorMessage);
+                promise->reject("Error while trying to open the file: " + errorMessage);
+                return;
+            }
 
-                    std::int32_t bytesToRead = length < 0 ? std::min(fileSize, fileSize - bytesToSkip)
-                                                          : std::min(length, fileSize - bytesToSkip);
+            if (bytesToSkip >= fileSize) {
+                TMERROR("[ExponentFileSystem] cannot skip beyond end of file!");
+                promise->reject("Cannot skip beyond end of file");
+                return;
+            }
 
-                    stream.seekg(bytesToSkip, std::ios::beg);
-                    std::string content;
-                    content.resize(bytesToRead);
-                    stream.read(&content[0], bytesToRead);
-                    volta::react::KPLog.debug("[ExponentFileSystem] content: {}", content);
+            std::int32_t bytesToRead =
+                    length < 0 ? std::min(fileSize, fileSize - bytesToSkip) : std::min(length, fileSize - bytesToSkip);
 
-                    if (desiredEncoding == "base64") {
-                        volta::react::KPLog.debug("[base64] base64 encoding...");
-                        promise->resolve(base64Encode(content));
-                    } else {
-                        promise->resolve(content);
-                    }
-                } catch (std::exception& e) {
-                    volta::react::KPLog.error("[ExponentFileSystem] reading file exception reason: {}", e.what());
-                    promise->reject(e.what());
-                }
-            });
+            stream.seekg(bytesToSkip, std::ios::beg);
+            std::string content;
+            content.resize(bytesToRead);
+            stream.read(&content[0], bytesToRead);
+            TMDEBUG(std::string("[ExponentFileSystem] content: ") + content);
+
+            if (desiredEncoding == "base64") {
+                TMDEBUG("[base64] base64 encoding...");
+                promise->resolve(base64Encode(content));
+            } else {
+                promise->resolve(content);
+            }
+        } catch (std::exception& e) {
+            TMERROR(std::string("[ExponentFileSystem] reading file exception reason: ") + e.what());
+            promise->reject(e.what());
+        }
+    });
 };
 
-volta::react::Promise ExponentFileSystem::getContentUriAsync(const std::string fileUri) {
-    return volta::react::Promise([this, &fileUri](std::shared_ptr<volta::react::Promise> promise) {
+Promise ExponentFileSystem::getContentUriAsync(const std::string fileUri) {
+    return Promise([this, &fileUri](std::shared_ptr<Promise> promise) {
         std::string contentUri = std::filesystem::absolute(fileUri);
 
         promise->resolve(contentUri);
     });
 };
 
-volta::react::Promise ExponentFileSystem::writeAsStringAsync(
+Promise ExponentFileSystem::writeAsStringAsync(
         const std::string fileUri,
         const std::string contents,
-        volta::react::NativeJSObject options) {
+        NativeJSObject options) {
     std::string desiredEncoding = getOrDefault(options, "encoding", std::string("utf8"));
 
-    return volta::react::Promise(
-            [this, fileUri, contents, desiredEncoding](std::shared_ptr<volta::react::Promise> promise) {
-                try {
-                    std::ofstream stream(fileUri);
-                    volta::react::KPLog.debug("[ExponentFileSystem] trying to open the file: {} for write", fileUri);
-                    if (stream.fail()) {
-                        volta::react::KPLog.error("[ExponentFileSystem] unable to open file at {} for write", fileUri);
-                        promise->reject("Error while trying to open the file");
-                        return;
-                    } else {
-                        if (desiredEncoding == "base64") {
-                            stream << base64Encode(contents);
-                        } else {
-                            stream << contents;
-                        }
+    return Promise([this, fileUri, contents, desiredEncoding](std::shared_ptr<Promise> promise) {
+        try {
+            std::ofstream stream(fileUri);
+            TMDEBUG(std::string("[ExponentFileSystem] trying to open the file: ") + fileUri + " for write");
+            if (stream.fail()) {
+                std::string errorMessage = std::strerror(errno);
+                TMERROR(std::string("[ExponentFileSystem] unable to open file at ") + fileUri + " for write: " + errorMessage);
+                promise->reject("Error while trying to open the file: " + errorMessage);
+                return;
+            } else {
+                if (desiredEncoding == "base64") {
+                    stream << base64Encode(contents);
+                } else {
+                    stream << contents;
+                }
 
-                        if (stream.fail()) {
-                            volta::react::KPLog.error("[ExponentFileSystem] error while writing to file");
-                            promise->reject("Error while trying to write to the file");
-                            return;
-                        }
-                        stream.close();
-                    }
-                    promise->resolve();
-                } catch (std::exception& e) {
-                    volta::react::KPLog.error("[ExponentFileSystem] writing file exception reason: {}", e.what());
-                    promise->reject(e.what());
+                if (stream.fail()) {
+                    std::string errorMessage = std::strerror(errno);
+                    TMERROR(std::string("[ExponentFileSystem] error while writing to file: ") + errorMessage);
+                    promise->reject("Error while trying to write to the file: " + errorMessage);
+                    return;
                 }
-            });
+                stream.close();
+            }
+            promise->resolve(NULL);
+        } catch (std::exception& e) {
+            TMERROR(std::string("[ExponentFileSystem] writing file exception reason: ") + e.what());
+            promise->reject(e.what());
+        }
+    });
 };
 
-volta::react::Promise ExponentFileSystem::writeArrayBufferAsync(
-        const std::string fileUri,
-        const volta::react::ArrayBuffer arrayBuffer) {
-    return volta::react::Promise([this, fileUri, arrayBuffer](std::shared_ptr<volta::react::Promise> promise) {
+Promise ExponentFileSystem::writeArrayBufferAsync(const std::string fileUri, const ArrayBuffer arrayBuffer) {
+    return Promise([this, fileUri, arrayBuffer](std::shared_ptr<Promise> promise) {
         try {
             std::ofstream file(fileUri, std::ios::binary);
-            std::shared_ptr<std::vector<uint8_t>> dataPtr = arrayBuffer.dataVector();
+            auto dataPtr =
+                    std::make_shared<std::vector<uint8_t>>(arrayBuffer.data(), arrayBuffer.data() + arrayBuffer.size());
 
             if (file.fail()) {
-                volta::react::KPLog.error("[ExponentFileSystem] unable to open file at {} for response write", fileUri);
-                promise->reject("File while tring to open the file");
+                std::string errorMessage = std::strerror(errno);
+                TMERROR(std::string("[ExponentFileSystem] unable to open file at ") + fileUri + " for response write: " + errorMessage);
+                promise->reject("File while tring to open the file: " + errorMessage);
                 return;
             } else {
                 if (dataPtr && !dataPtr->empty()) {
                     file.write(reinterpret_cast<const char*>(dataPtr->data()), dataPtr->size());
                     if (file.fail()) {
-                        volta::react::KPLog.error("[ExponentFileSystem] error while writing response to file");
-                        promise->reject("Error while trying to write response to file");
+                        std::string errorMessage = std::strerror(errno);
+                        TMERROR(std::string("[ExponentFileSystem] error while writing response to file: ") + errorMessage);
+                        promise->reject("Error while trying to write response to file: " + errorMessage);
                         return;
                     }
                 }
             }
-            promise->resolve();
+            promise->resolve(NULL);
         } catch (std::exception& e) {
-            volta::react::KPLog.error("[ExponentFileSystem] writing file exception reason: {}", e.what());
+            TMERROR(std::string("[ExponentFileSystem] writing file exception reason: ") + e.what());
             promise->reject(e.what());
         }
     });
 }
 
-volta::react::Promise ExponentFileSystem::deleteAsync(const std::string fileUri, volta::react::NativeJSObject options) {
+Promise ExponentFileSystem::deleteAsync(const std::string fileUri, NativeJSObject options) {
     bool idempotent = getOrDefault(options, "idempotent", false);
 
-    return volta::react::Promise([this, fileUri, idempotent](std::shared_ptr<volta::react::Promise> promise) {
+    return Promise([this, fileUri, idempotent](std::shared_ptr<Promise> promise) {
         if (!std::filesystem::exists(fileUri)) {
             if (idempotent) {
-                promise->resolve();
+                promise->resolve(NULL);
                 return;
             } else {
-                volta::react::KPLog.error("[ExponentFileSystem] file does not exist at the specified URI!");
+                TMERROR("[ExponentFileSystem] file does not exist at the specified URI!");
                 promise->reject("File does not exist at the specified URI");
                 return;
             }
@@ -283,77 +294,73 @@ volta::react::Promise ExponentFileSystem::deleteAsync(const std::string fileUri,
         if (std::filesystem::is_regular_file(fileUri)) {
             try {
                 std::filesystem::remove(fileUri);
-                promise->resolve();
+                promise->resolve(NULL);
             } catch (std::filesystem::filesystem_error& e) {
-                volta::react::KPLog.error("[ExponentFileSystem] file deletion exception, reason: {}", e.what());
+                TMERROR(std::string("[ExponentFileSystem] file deletion exception, reason: ") + e.what());
                 promise->reject(e.what());
             }
         } else {
-            volta::react::KPLog.error("[ExponentFileSystem] resource is not a regular file!");
+            TMERROR("[ExponentFileSystem] resource is not a regular file!");
             promise->reject("Resource is not a regular file");
         }
     });
 };
 
-volta::react::Promise ExponentFileSystem::moveAsync(volta::react::NativeJSObject options) {
+Promise ExponentFileSystem::moveAsync(NativeJSObject options) {
     std::string from = getOrDefault(options, "from", std::string(""));
     std::string to = getOrDefault(options, "to", std::string(""));
 
-    return volta::react::Promise([this, from, to](std::shared_ptr<volta::react::Promise> promise) {
+    return Promise([this, from, to](std::shared_ptr<Promise> promise) {
         if (from.empty() || to.empty()) {
-            volta::react::KPLog.error(
-                    "[ExponentFileSystem]::moveAsync 'from' or 'to' not provided but they are both required");
+            TMERROR("[ExponentFileSystem]::moveAsync 'from' or 'to' not provided but they are both required");
             promise->reject("'from' or 'to' not provided but they are both required");
             return;
         }
 
         try {
             std::filesystem::rename(from, to);
-            promise->resolve();
+            promise->resolve(NULL);
         } catch (std::filesystem::filesystem_error& e) {
-            volta::react::KPLog.error("[ExponentFileSystem] file transfer exception, reason: {}", e.what());
+            TMERROR(std::string("[ExponentFileSystem] file transfer exception, reason: ") + e.what());
             promise->reject(e.what());
         }
     });
 };
 
-volta::react::Promise ExponentFileSystem::copyAsync(volta::react::NativeJSObject options) {
+Promise ExponentFileSystem::copyAsync(NativeJSObject options) {
     std::string from = getOrDefault(options, "from", std::string(""));
     std::string to = getOrDefault(options, "to", std::string(""));
 
-    return volta::react::Promise([this, from, to](std::shared_ptr<volta::react::Promise> promise) {
+    return Promise([this, from, to](std::shared_ptr<Promise> promise) {
         if (from.empty() || to.empty()) {
-            volta::react::KPLog.error(
-                    "[ExponentFileSystem]::copyAsync 'from' or 'to' not provided but they are both required");
+            TMERROR("[ExponentFileSystem]::copyAsync 'from' or 'to' not provided but they are both required");
             promise->reject("'from' or 'to' not provided but they are both required");
             return;
         }
 
         try {
             std::filesystem::copy(from, to, std::filesystem::copy_options::recursive);
-            promise->resolve();
+            promise->resolve(NULL);
         } catch (std::filesystem::filesystem_error& e) {
-            volta::react::KPLog.error("[ExponentFileSystem] file transfer exception, reason: {}", e.what());
+            TMERROR(std::string("[ExponentFileSystem] file transfer exception, reason: ") + e.what());
             promise->reject(e.what());
         }
     });
 };
 
-volta::react::Promise ExponentFileSystem::makeDirectoryAsync(
-        const std::string fileUri,
-        volta::react::NativeJSObject options) {
+Promise ExponentFileSystem::makeDirectoryAsync(const std::string fileUri, NativeJSObject options) {
     bool idempotent = getOrDefault(options, "intermediates", false);
 
-    return volta::react::Promise([this, fileUri, idempotent](std::shared_ptr<volta::react::Promise> promise) {
+    return Promise([this, fileUri, idempotent](std::shared_ptr<Promise> promise) {
         try {
             bool exists = std::filesystem::exists(fileUri);
 
             if (exists) {
                 if (idempotent) {
-                    promise->resolve();
+                    promise->resolve(NULL);
                     return;
                 }
-                volta::react::KPLog.error("[ExponentFileSystem] directory already exists!");
+                TMERROR("[ExponentFileSystem] directory already exists!");
                 promise->reject("Directory already exists");
                 return;
             }
@@ -361,36 +368,34 @@ volta::react::Promise ExponentFileSystem::makeDirectoryAsync(
             std::error_code errorCode;
 
             if (std::filesystem::create_directories(fileUri, errorCode)) {
-                volta::react::KPLog.debug("[ExponentFileSystem] directory created successfully!");
+                TMDEBUG("[ExponentFileSystem] directory created successfully!");
             } else {
-                volta::react::KPLog.error(
-                        "[ExponentFileSystem] directory creation failed, message: {}",
-                        errorCode.message());
+                TMERROR(std::string("[ExponentFileSystem] directory creation failed, message: ") + errorCode.message());
                 promise->reject(errorCode.message());
                 return;
             }
-            promise->resolve();
+            promise->resolve(NULL);
         } catch (std::exception& e) {
-            volta::react::KPLog.error("[ExponentFileSystem] directory creation exception, reason: {}", e.what());
+            TMERROR(std::string("[ExponentFileSystem] directory creation exception, reason: ") + e.what());
             promise->reject(e.what());
         }
     });
 };
 
-volta::react::Promise ExponentFileSystem::readDirectoryAsync(const std::string fileUri) {
-    return volta::react::Promise([this, fileUri](std::shared_ptr<volta::react::Promise> promise) {
+Promise ExponentFileSystem::readDirectoryAsync(const std::string fileUri) {
+    return Promise([this, fileUri](std::shared_ptr<Promise> promise) {
         try {
             if (!std::filesystem::exists(fileUri)) {
-                volta::react::KPLog.error("[ExponentFileSystem] directory does not exist at the specified URI!");
+                TMERROR("[ExponentFileSystem] directory does not exist at the specified URI!");
                 promise->reject("Directory does not exist at the specified URI");
                 return;
             } else if (!std::filesystem::is_directory(fileUri)) {
-                volta::react::KPLog.error("[ExponentFileSystem] resource at the specified URI is not a directory!");
+                TMERROR("[ExponentFileSystem] resource at the specified URI is not a directory!");
                 promise->reject("Resource at the specified URI is not a directory");
                 return;
             }
 
-            auto childrenNames = volta::react::NativeJSArray{};
+            auto childrenNames = NativeJSArray{};
 
             // Symbolic links of the directory entries are not followed
             // during this enumeration.
@@ -400,60 +405,173 @@ volta::react::Promise ExponentFileSystem::readDirectoryAsync(const std::string f
 
             promise->resolve(childrenNames);
         } catch (std::exception& e) {
-            volta::react::KPLog.error("[ExponentFileSystem] Reading directory exception: {}", e.what());
+            TMERROR(std::string("[ExponentFileSystem] Reading directory exception: ") + e.what());
             promise->reject(e.what());
         }
     });
 };
 
-volta::react::Promise ExponentFileSystem::getFreeDiskStorageAsync() {
-    return volta::react::Promise([](std::shared_ptr<volta::react::Promise> promise) {
+Promise ExponentFileSystem::getFreeDiskStorageAsync() {
+    return Promise([](std::shared_ptr<Promise> promise) {
         try {
             std::string path = std::filesystem::absolute("data");
 
             std::error_code errorCode;
             std::filesystem::space_info spaceInfo = std::filesystem::space(path, errorCode);
             if (errorCode) {
-                volta::react::KPLog.error(
-                        "[ExponentFileSystem] Error when getting free disk space: {}",
-                        errorCode.message());
+                TMERROR(std::string("[ExponentFileSystem] Error when getting free disk space: ") + errorCode.message());
                 promise->reject(errorCode.message());
                 return;
             }
-            volta::react::KPLog.debug("[ExponentFileSystem] Free space: {}", std::to_string(spaceInfo.available));
+            TMDEBUG(std::string("[ExponentFileSystem] Free space: ") + std::to_string(spaceInfo.available));
             promise->resolve(std::to_string(spaceInfo.available));
         } catch (std::exception& e) {
-            volta::react::KPLog.error("[ExponentFileSystem] Getting free disk storage exception: {}", e.what());
+            TMERROR(std::string("[ExponentFileSystem] Getting free disk storage exception: ") + e.what());
             promise->reject(e.what());
         }
     });
 };
 
-volta::react::Promise ExponentFileSystem::getTotalDiskCapacityAsync() {
-    return volta::react::Promise([](std::shared_ptr<volta::react::Promise> promise) { promise->resolve(); });
+Promise ExponentFileSystem::getTotalDiskCapacityAsync() {
+    return Promise([](std::shared_ptr<Promise> promise) { promise->resolve(NULL); });
 };
 
-volta::react::Promise ExponentFileSystem::downloadAsync(
-        const std::string,
-        const std::string,
-        volta::react::NativeJSObject,
-        double,
-        std::vector<utils::json::JsonContainer>) {
-    return volta::react::Promise([](std::shared_ptr<volta::react::Promise> promise) {
-        promise->reject("downloadAsync method has been deprecated, Update expo-file-system npm package");
-    });
-};
+Promise ExponentFileSystem::downloadAsync(
+        const std::string url,
+        const std::string fileUri,
+        NativeJSObject options,
+        double /* requestId */,
+        std::vector<utils::json::JsonContainer> headers) {
+    bool shouldComputeMd5 = getOrDefault(options, "md5", false);
+
+    // Convert headers vector to std::map
+    std::map<std::string, std::string> requestHeaders;
+    for (auto header : headers) {
+        try {
+            auto key = header["key"].getValue<std::string>();
+            auto value = header["value"].getValue<std::string>();
+            requestHeaders[key] = value;
+        } catch (...) {
+            // Skip malformed header entries
+        }
+    }
 
-volta::react::Promise ExponentFileSystem::uploadAsync(
-        const std::string,
-        const std::string,
-        volta::react::NativeJSObject,
-        double,
-        std::vector<utils::json::JsonContainer>) {
-    return volta::react::Promise([](std::shared_ptr<volta::react::Promise> promise) {
-        promise->reject("uploadAsync method has been deprecated, Update expo-file-system npm package");
-    });
-};
+    return Promise(
+            [this, url, fileUri, shouldComputeMd5, requestHeaders](std::shared_ptr<Promise> promise) {
+                TMDEBUG(std::string("[ExponentFileSystem] downloadAsync: ") + url + " -> " + fileUri);
+
+                // Run curl on a background thread to avoid blocking the JS thread.
+                // curl_easy_perform is synchronous and will block for the entire download
+                // duration, which triggers the KeplerScript thread watchdog on large files.
+                auto curlWrapper = curlWrapper_.get();
+                std::thread([promise, curlWrapper, url, fileUri, shouldComputeMd5, requestHeaders]() {
+                    auto result = curlWrapper->downloadToFile(url, fileUri, requestHeaders);
+
+                    if (!result.success) {
+                        TMERROR(std::string("[ExponentFileSystem] downloadAsync failed: ") + result.errorMessage);
+                        promise->reject(result.errorMessage);
+                        return;
+                    }
+
+                    // Build response headers as NativeJSObject
+                    auto responseHeaders = NativeJSObject{};
+                    std::string mimeType;
+                    for (const auto& [key, value] : result.headers) {
+                        if (key == "__response_body__") continue;
+                        responseHeaders.insert({key, value});
+                        std::string lowerKey = key;
+                        std::transform(lowerKey.begin(), lowerKey.end(), lowerKey.begin(), ::tolower);
+                        if (lowerKey == "content-type") {
+                            mimeType = value.substr(0, value.find(';'));
+                        }
+                    }
+
+                    auto downloadResult = NativeJSObject{
+                            {"uri", fileUri},
+                            {"status", static_cast<double>(result.statusCode)},
+                            {"headers", responseHeaders},
+                            {"mimeType", mimeType.empty() ? std::string("") : mimeType}};
+
+                    if (shouldComputeMd5) {
+                        try {
+                            std::ifstream stream(fileUri, std::ios::binary);
+                            if (stream.good()) {
+                                std::stringstream buffer;
+                                buffer << stream.rdbuf();
+                                downloadResult.insert({"md5", md5Hash(buffer.str())});
+                            }
+                        } catch (std::exception& e) {
+                            TMERROR(std::string("[ExponentFileSystem] MD5 computation failed: ") + e.what());
+                        }
+                    }
+
+                    promise->resolve(downloadResult);
+                }).detach();
+            });
+}
+
+Promise ExponentFileSystem::uploadAsync(
+        const std::string url,
+        const std::string fileUri,
+        NativeJSObject options,
+        double /* requestId */,
+        std::vector<utils::json::JsonContainer> headers) {
+    std::string httpMethod = getOrDefault(options, "httpMethod", std::string("POST"));
+
+    // Convert headers vector to std::map
+    std::map<std::string, std::string> requestHeaders;
+    for (auto header : headers) {
+        try {
+            auto key = header["key"].getValue<std::string>();
+            auto value = header["value"].getValue<std::string>();
+            requestHeaders[key] = value;
+        } catch (...) {
+            // Skip malformed header entries
+        }
+    }
+
+    return Promise(
+            [this, url, fileUri, httpMethod, requestHeaders](std::shared_ptr<Promise> promise) {
+                TMDEBUG(std::string("[ExponentFileSystem] uploadAsync: ") + fileUri + " -> " + url + " (" + httpMethod + ")");
+
+                // Run curl on a background thread to avoid blocking the JS thread.
+                auto curlWrapper = curlWrapper_.get();
+                std::thread([promise, curlWrapper, url, fileUri, httpMethod, requestHeaders]() {
+                    auto result = curlWrapper->uploadFromFile(url, fileUri, httpMethod, requestHeaders);
+
+                    if (!result.success) {
+                        TMERROR(std::string("[ExponentFileSystem] uploadAsync failed: ") + result.errorMessage);
+                        promise->reject(result.errorMessage);
+                        return;
+                    }
+
+                    // Build response headers as NativeJSObject
+                    auto responseHeaders = NativeJSObject{};
+                    std::string mimeType;
+                    std::string responseBody;
+                    for (const auto& [key, value] : result.headers) {
+                        if (key == "__response_body__") {
+                            responseBody = value;
+                            continue;
+                        }
+                        responseHeaders.insert({key, value});
+                        std::string lowerKey = key;
+                        std::transform(lowerKey.begin(), lowerKey.end(), lowerKey.begin(), ::tolower);
+                        if (lowerKey == "content-type") {
+                            mimeType = value.substr(0, value.find(';'));
+                        }
+                    }
+
+                    auto uploadResult = NativeJSObject{
+                            {"body", responseBody},
+                            {"status", static_cast<double>(result.statusCode)},
+                            {"headers", responseHeaders},
+                            {"mimeType", mimeType.empty() ? std::string("") : mimeType}};
+
+                    promise->resolve(uploadResult);
+                }).detach();
+            });
+}
 
 std::uintmax_t ExponentFileSystem::getSize(const std::string& path) {
     if (std::filesystem::is_regular_file(path)) {
@@ -475,8 +593,9 @@ std::uintmax_t ExponentFileSystem::getSize(const std::string& path) {
 };
 
 void ExponentFileSystem::aggregateMethods(
-        volta::react::MethodAggregator<volta::react::KeplerTurboModule>& methodAggregator) const noexcept {
-    volta::react::KPLog.debug("methodAggregator");
+        com::amazon::kepler::turbomodule::MethodAggregator<com::amazon::kepler::turbomodule::KeplerTurboModule>&
+                methodAggregator) const noexcept {
+    TMDEBUG("methodAggregator");
 
     methodAggregator.addMethod("documentDirectory", 0, &ExponentFileSystem::documentDirectory);
     methodAggregator.addMethod("cacheDirectory", 0, &ExponentFileSystem::cacheDirectory);
@@ -494,5 +613,5 @@ void ExponentFileSystem::aggregateMethods(
     methodAggregator.addMethod("getFreeDiskStorageAsync", 0, &ExponentFileSystem::getFreeDiskStorageAsync);
     methodAggregator.addMethod("getTotalDiskCapacityAsync", 0, &ExponentFileSystem::getTotalDiskCapacityAsync);
     methodAggregator.addMethod("downloadAsync", 5, &ExponentFileSystem::downloadAsync);
-    methodAggregator.addMethod("uploadAsync", 4, &ExponentFileSystem::uploadAsync);
+    methodAggregator.addMethod("uploadAsync", 5, &ExponentFileSystem::uploadAsync);
 }