@cetapod/react-native-smb 1.0.0

package/cpp/shared/ReactNativeSmb.hpp

@@ -0,0 +1,428 @@
+#include <unordered_map>
+#pragma once
+
+#include <NitroModules/HybridObject.hpp>
+#include <NitroModules/JSIConverter.hpp>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "core/SmbTask.hpp"
+
+namespace react_native_smb {
+using namespace margelo::nitro;
+
+using SmbStatusCallback = std::function<void(const std::string&, const std::string&, int)>;
+using SmbProgressCallback = std::function<void(double, double)>;
+
+struct SmbCredentials {
+    std::string username;
+    std::string password;
+};
+
+struct SmbShareList {
+    std::string name;
+    std::string comment;
+};
+
+struct SmbConnectionInfo {
+    std::string url;
+    std::string server;
+    std::string share;
+    bool isConnected;
+};
+
+struct SmbFileInfo {
+    std::string name;
+    std::string path;
+    int64_t size;
+    bool isDirectory;
+    int64_t modifiedAt;                 // Content modification time (smb2_mtime)
+    int64_t accessedAt;                 // Last access time (smb2_atime)
+    int64_t createdAt;                  // Creation time (smb2_btime)
+    int64_t changedAt;                  // Attribute change time (smb2_ctime)
+    int64_t childCount;                 // Directories: number of immediate children; -1 if unknown / not a directory
+    std::vector<SmbFileInfo> children;  // Nested children for directories (when recursive)
+};
+
+struct SmbAce {
+    std::string aceType;                // Type of ACE (e.g., "ACCESS_ALLOWED_ACE",
+                                        // "ACCESS_DENIED_ACE")
+    std::vector<std::string> aceFlags;  // Flags for the ACE (e.g.,
+                                        // "INHERIT_ONLY", "NO_PROPAGATE_INHERIT")
+    std::vector<std::string> mask;      // Access mask (e.g., "READ", "WRITE", "EXECUTE")
+    std::string sid;                    // Security Identifier
+};
+
+struct SmbAcl {
+    uint8_t revision;
+    uint16_t aceCount;
+    std::vector<SmbAce> aces;
+};
+
+struct SmbSecurityDescriptor {
+    uint8_t revision;
+    std::vector<std::string> control;
+    std::string ownerSid;
+    std::string groupSid;
+    SmbAcl dacl;
+};
+
+class ReactNativeSmb : public virtual HybridObject {
+   public:
+    virtual ~ReactNativeSmb() = default;
+
+    virtual bool isConnected() = 0;
+    virtual bool isInitialized() = 0;
+
+    // --- Connection Management ---
+    virtual std::shared_ptr<SmbTask> initialize(const std::string& taskId, const std::string& url, const SmbCredentials& credentials) = 0;
+    virtual std::shared_ptr<SmbTask> connect(const std::string& taskId, const std::string& url, const SmbCredentials& credentials) = 0;
+    virtual std::shared_ptr<SmbTask> connectShare(const std::string& taskId, const std::string& share) = 0;
+    virtual std::shared_ptr<SmbTask> disconnect(const std::string& taskId) = 0;
+    virtual std::shared_ptr<SmbTask> listShares(const std::string& taskId) = 0;
+
+    // --- Listing & Info ---
+    virtual std::shared_ptr<SmbTask> listDirectory(const std::string& taskId, const std::string& path, bool recursive, int maxDepth) = 0;
+    virtual std::shared_ptr<SmbTask> getPathInfo(const std::string& taskId, const std::string& path) = 0;
+    virtual std::shared_ptr<SmbTask> getSecurityDescriptor(const std::string& taskId, const std::string& path) = 0;
+
+    // --- File Transfers ---
+    virtual std::shared_ptr<SmbTask> downloadFile(const std::string& taskId, const std::string& remotePath, const std::string& localPath) = 0;
+    virtual std::shared_ptr<SmbTask> uploadFile(const std::string& taskId, const std::string& localPath, const std::string& remotePath) = 0;
+
+    // --- Mutating File Operations ---
+    virtual std::shared_ptr<SmbTask> createDirectory(const std::string& taskId, const std::string& path) = 0;
+    virtual std::shared_ptr<SmbTask> deleteItem(const std::string& taskId, const std::string& path) = 0;
+    virtual std::shared_ptr<SmbTask> moveItem(const std::string& taskId, const std::string& fromPath, const std::string& toPath) = 0;
+    virtual std::shared_ptr<SmbTask> renameItem(const std::string& taskId, const std::string& currentPath, const std::string& newName) = 0;
+    virtual std::shared_ptr<SmbTask> copyItem(const std::string& taskId, const std::string& fromPath, const std::string& toPath, bool recursive) = 0;
+    virtual std::shared_ptr<SmbTask> duplicateItem(const std::string& taskId, const std::string& path) = 0;
+
+    // --- Task control & Task Center APIs ---
+    virtual std::string subscribeTaskEvents(const std::function<void(const std::unordered_map<std::string, std::string>&)>& listener) = 0;
+    virtual void unsubscribeTaskEvents(const std::string& subscriptionId) = 0;
+    virtual std::unordered_map<std::string, std::string> getTask(const std::string& taskId) = 0;
+    virtual std::vector<std::unordered_map<std::string, std::string>> getActiveTasks() = 0;
+    virtual std::vector<std::unordered_map<std::string, std::string>> getTaskHistory(int limit, int offset) = 0;
+    virtual void cancelTask(const std::string& taskId) = 0;
+    virtual void clearTaskHistory(int64_t beforeTs) = 0;
+
+    // Debug / instrumentation
+    virtual std::string subscribePoolInfo(const std::function<void(const std::vector<std::unordered_map<std::string, std::string>>&)>& listener) = 0;
+    virtual void unsubscribePoolInfo(const std::string& subscriptionId) = 0;
+    virtual std::vector<std::unordered_map<std::string, std::string>> getPoolInfo() = 0;
+    virtual void resetPool() = 0;
+
+   protected:
+    static constexpr auto NAME = "ReactNativeSmb";
+};
+
+}  // namespace react_native_smb
+
+namespace margelo::nitro {
+using namespace react_native_smb;
+
+template <>
+struct JSIConverter<SmbCredentials> {
+    static jsi::Value toJSI(jsi::Runtime& runtime, const SmbCredentials& credentials) {
+        jsi::Object obj(runtime);
+        obj.setProperty(runtime, "username", jsi::String::createFromUtf8(runtime, credentials.username));
+        obj.setProperty(runtime, "password", jsi::String::createFromUtf8(runtime, credentials.password));
+        return obj;
+    }
+
+    static SmbCredentials fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+        if (!value.isObject()) {
+            throw std::invalid_argument("SmbCredentials must be an object");
+        }
+
+        jsi::Object obj = value.asObject(runtime);
+        SmbCredentials credentials;
+
+        credentials.username = obj.getProperty(runtime, "username").asString(runtime).utf8(runtime);
+        credentials.password = obj.getProperty(runtime, "password").asString(runtime).utf8(runtime);
+
+        return credentials;
+    }
+
+    static bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { return value.isObject(); }
+};
+
+template <>
+struct JSIConverter<SmbConnectionInfo> {
+    static jsi::Value toJSI(jsi::Runtime& runtime, const SmbConnectionInfo& connection) {
+        jsi::Object obj(runtime);
+        obj.setProperty(runtime, "url", jsi::String::createFromUtf8(runtime, connection.url));
+        obj.setProperty(runtime, "server", jsi::String::createFromUtf8(runtime, connection.server));
+        obj.setProperty(runtime, "share", jsi::String::createFromUtf8(runtime, connection.share));
+        obj.setProperty(runtime, "isConnected", jsi::Value(connection.isConnected));
+        return obj;
+    }
+
+    static SmbConnectionInfo fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+        if (!value.isObject()) {
+            throw std::invalid_argument("SmbConnectionInfo must be an object");
+        }
+
+        jsi::Object obj = value.asObject(runtime);
+        return SmbConnectionInfo{obj.getProperty(runtime, "url").asString(runtime).utf8(runtime), obj.getProperty(runtime, "server").asString(runtime).utf8(runtime),
+                                 obj.getProperty(runtime, "share").asString(runtime).utf8(runtime), obj.getProperty(runtime, "isConnected").asBool()};
+    }
+
+    static bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { return value.isObject(); }
+};
+
+template <>
+struct JSIConverter<SmbFileInfo> {
+    static jsi::Value toJSI(jsi::Runtime& runtime, const SmbFileInfo& fileInfo) {
+        jsi::Object obj(runtime);
+        obj.setProperty(runtime, "name", jsi::String::createFromUtf8(runtime, fileInfo.name));
+        obj.setProperty(runtime, "path", jsi::String::createFromUtf8(runtime, fileInfo.path));
+        obj.setProperty(runtime, "size", jsi::Value(static_cast<double>(fileInfo.size)));
+        obj.setProperty(runtime, "isDirectory", jsi::Value(fileInfo.isDirectory));
+        obj.setProperty(runtime, "modifiedAt", jsi::Value(static_cast<double>(fileInfo.modifiedAt)));
+        obj.setProperty(runtime, "accessedAt", jsi::Value(static_cast<double>(fileInfo.accessedAt)));
+        obj.setProperty(runtime, "createdAt", jsi::Value(static_cast<double>(fileInfo.createdAt)));
+        obj.setProperty(runtime, "changedAt", jsi::Value(static_cast<double>(fileInfo.changedAt)));
+        obj.setProperty(runtime, "childCount", jsi::Value(static_cast<double>(fileInfo.childCount)));
+
+        jsi::Array childrenArray(runtime, fileInfo.children.size());
+        for (size_t i = 0; i < fileInfo.children.size(); i++) {
+            childrenArray.setValueAtIndex(runtime, i, toJSI(runtime, fileInfo.children[i]));
+        }
+        obj.setProperty(runtime, "children", std::move(childrenArray));
+
+        return obj;
+    }
+
+    static SmbFileInfo fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+        if (!value.isObject()) {
+            throw std::invalid_argument("SmbFileInfo must be an object");
+        }
+
+        jsi::Object obj = value.asObject(runtime);
+
+        std::vector<SmbFileInfo> children;
+        if (obj.hasProperty(runtime, "children")) {
+            jsi::Value childrenValue = obj.getProperty(runtime, "children");
+            if (childrenValue.isObject() && childrenValue.asObject(runtime).isArray(runtime)) {
+                jsi::Array childrenArray = childrenValue.asObject(runtime).asArray(runtime);
+                size_t childrenCount = childrenArray.size(runtime);
+                children.reserve(childrenCount);
+
+                for (size_t i = 0; i < childrenCount; i++) {
+                    jsi::Value childValue = childrenArray.getValueAtIndex(runtime, i);
+                    children.push_back(fromJSI(runtime, childValue));
+                }
+            }
+        }
+
+        return SmbFileInfo{obj.getProperty(runtime, "name").asString(runtime).utf8(runtime),
+                           obj.getProperty(runtime, "path").asString(runtime).utf8(runtime),
+                           static_cast<int64_t>(obj.getProperty(runtime, "size").asNumber()),
+                           obj.getProperty(runtime, "isDirectory").asBool(),
+                           static_cast<int64_t>(obj.getProperty(runtime, "modifiedAt").asNumber()),
+                           static_cast<int64_t>(obj.hasProperty(runtime, "accessedAt") ? obj.getProperty(runtime, "accessedAt").asNumber() : 0),
+                           static_cast<int64_t>(obj.hasProperty(runtime, "createdAt") ? obj.getProperty(runtime, "createdAt").asNumber() : 0),
+                           static_cast<int64_t>(obj.hasProperty(runtime, "changedAt") ? obj.getProperty(runtime, "changedAt").asNumber() : 0),
+                           static_cast<int64_t>(obj.hasProperty(runtime, "childCount") ? obj.getProperty(runtime, "childCount").asNumber() : -1),
+                           children};
+    }
+
+    static bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { return value.isObject(); }
+};
+
+template <>
+struct JSIConverter<SmbShareList> {
+    static jsi::Value toJSI(jsi::Runtime& runtime, const SmbShareList& share) {
+        jsi::Object obj(runtime);
+        obj.setProperty(runtime, "name", jsi::String::createFromUtf8(runtime, share.name));
+        obj.setProperty(runtime, "comment", jsi::String::createFromUtf8(runtime, share.comment));
+        return obj;
+    }
+
+    static SmbShareList fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+        if (!value.isObject()) {
+            throw std::invalid_argument("SmbShareList must be an object");
+        }
+
+        jsi::Object obj = value.asObject(runtime);
+        return SmbShareList{obj.getProperty(runtime, "name").asString(runtime).utf8(runtime), obj.getProperty(runtime, "comment").asString(runtime).utf8(runtime)};
+    }
+
+    static bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { return value.isObject(); }
+};
+
+template <>
+struct JSIConverter<SmbAce> {
+    static jsi::Value toJSI(jsi::Runtime& runtime, const SmbAce& ace) {
+        jsi::Object obj(runtime);
+        obj.setProperty(runtime, "aceType", jsi::String::createFromUtf8(runtime, ace.aceType));
+
+        jsi::Array aceFlagsArray = jsi::Array(runtime, ace.aceFlags.size());
+        for (size_t i = 0; i < ace.aceFlags.size(); i++) {
+            aceFlagsArray.setValueAtIndex(runtime, i, jsi::String::createFromUtf8(runtime, ace.aceFlags[i]));
+        }
+        obj.setProperty(runtime, "aceFlags", aceFlagsArray);
+
+        jsi::Array maskArray = jsi::Array(runtime, ace.mask.size());
+        for (size_t i = 0; i < ace.mask.size(); i++) {
+            maskArray.setValueAtIndex(runtime, i, jsi::String::createFromUtf8(runtime, ace.mask[i]));
+        }
+        obj.setProperty(runtime, "mask", maskArray);
+
+        obj.setProperty(runtime, "sid", jsi::String::createFromUtf8(runtime, ace.sid));
+        return obj;
+    }
+
+    static SmbAce fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+        if (!value.isObject()) {
+            throw std::invalid_argument("SmbAce must be an object");
+        }
+
+        jsi::Object obj = value.asObject(runtime);
+        SmbAce ace;
+
+        ace.aceType = obj.getProperty(runtime, "aceType").asString(runtime).utf8(runtime);
+
+        if (obj.hasProperty(runtime, "aceFlags")) {
+            jsi::Value aceFlagsValue = obj.getProperty(runtime, "aceFlags");
+            if (aceFlagsValue.isObject() && aceFlagsValue.asObject(runtime).isArray(runtime)) {
+                jsi::Array aceFlagsArray = aceFlagsValue.asObject(runtime).asArray(runtime);
+                size_t flagsCount = aceFlagsArray.size(runtime);
+                ace.aceFlags.reserve(flagsCount);
+
+                for (size_t i = 0; i < flagsCount; i++) {
+                    jsi::Value flagItem = aceFlagsArray.getValueAtIndex(runtime, i);
+                    if (flagItem.isString()) {
+                        ace.aceFlags.push_back(flagItem.asString(runtime).utf8(runtime));
+                    }
+                }
+            }
+        }
+
+        if (obj.hasProperty(runtime, "mask")) {
+            jsi::Value maskValue = obj.getProperty(runtime, "mask");
+            if (maskValue.isObject() && maskValue.asObject(runtime).isArray(runtime)) {
+                jsi::Array maskArray = maskValue.asObject(runtime).asArray(runtime);
+                size_t maskCount = maskArray.size(runtime);
+                ace.mask.reserve(maskCount);
+
+                for (size_t i = 0; i < maskCount; i++) {
+                    jsi::Value maskItem = maskArray.getValueAtIndex(runtime, i);
+                    if (maskItem.isString()) {
+                        ace.mask.push_back(maskItem.asString(runtime).utf8(runtime));
+                    }
+                }
+            }
+        }
+
+        ace.sid = obj.getProperty(runtime, "sid").asString(runtime).utf8(runtime);
+
+        return ace;
+    }
+
+    static bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { return value.isObject(); }
+};
+
+template <>
+struct JSIConverter<SmbAcl> {
+    static jsi::Value toJSI(jsi::Runtime& runtime, const SmbAcl& acl) {
+        jsi::Object obj(runtime);
+        obj.setProperty(runtime, "revision", jsi::Value(static_cast<double>(acl.revision)));
+        obj.setProperty(runtime, "aceCount", jsi::Value(static_cast<double>(acl.aceCount)));
+
+        jsi::Array aces = jsi::Array(runtime, acl.aces.size());
+        for (size_t i = 0; i < acl.aces.size(); i++) {
+            aces.setValueAtIndex(runtime, i, JSIConverter<SmbAce>::toJSI(runtime, acl.aces[i]));
+        }
+        obj.setProperty(runtime, "aces", aces);
+
+        return obj;
+    }
+
+    static SmbAcl fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+        if (!value.isObject()) {
+            throw std::invalid_argument("SmbAcl must be an object");
+        }
+
+        jsi::Object obj = value.asObject(runtime);
+        SmbAcl acl;
+        acl.revision = static_cast<uint8_t>(obj.getProperty(runtime, "revision").asNumber());
+        acl.aceCount = static_cast<uint16_t>(obj.getProperty(runtime, "aceCount").asNumber());
+
+        if (obj.hasProperty(runtime, "aces")) {
+            jsi::Array aces = obj.getProperty(runtime, "aces").asObject(runtime).asArray(runtime);
+            size_t aceCount = aces.size(runtime);
+            acl.aces.reserve(aceCount);
+
+            for (size_t i = 0; i < aceCount; i++) {
+                jsi::Value aceValue = aces.getValueAtIndex(runtime, i);
+                acl.aces.push_back(JSIConverter<SmbAce>::fromJSI(runtime, aceValue));
+            }
+        }
+
+        return acl;
+    }
+
+    static bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { return value.isObject(); }
+};
+
+template <>
+struct JSIConverter<SmbSecurityDescriptor> {
+    static jsi::Value toJSI(jsi::Runtime& runtime, const SmbSecurityDescriptor& sd) {
+        jsi::Object obj(runtime);
+        obj.setProperty(runtime, "revision", jsi::Value(static_cast<double>(sd.revision)));
+
+        jsi::Array controlArray = jsi::Array(runtime, sd.control.size());
+        for (size_t i = 0; i < sd.control.size(); i++) {
+            controlArray.setValueAtIndex(runtime, i, jsi::String::createFromUtf8(runtime, sd.control[i]));
+        }
+        obj.setProperty(runtime, "control", controlArray);
+
+        obj.setProperty(runtime, "ownerSid", jsi::String::createFromUtf8(runtime, sd.ownerSid));
+        obj.setProperty(runtime, "groupSid", jsi::String::createFromUtf8(runtime, sd.groupSid));
+        obj.setProperty(runtime, "dacl", JSIConverter<SmbAcl>::toJSI(runtime, sd.dacl));
+        return obj;
+    }
+
+    static SmbSecurityDescriptor fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+        if (!value.isObject()) {
+            throw std::invalid_argument("SmbSecurityDescriptor must be an object");
+        }
+
+        jsi::Object obj = value.asObject(runtime);
+        SmbSecurityDescriptor sd;
+
+        sd.revision = static_cast<uint8_t>(obj.getProperty(runtime, "revision").asNumber());
+
+        if (obj.hasProperty(runtime, "control")) {
+            jsi::Value controlValue = obj.getProperty(runtime, "control");
+            if (controlValue.isObject() && controlValue.asObject(runtime).isArray(runtime)) {
+                jsi::Array controlArray = controlValue.asObject(runtime).asArray(runtime);
+                size_t controlCount = controlArray.size(runtime);
+                sd.control.reserve(controlCount);
+
+                for (size_t i = 0; i < controlCount; i++) {
+                    jsi::Value controlItem = controlArray.getValueAtIndex(runtime, i);
+                    if (controlItem.isString()) {
+                        sd.control.push_back(controlItem.asString(runtime).utf8(runtime));
+                    }
+                }
+            }
+        }
+
+        sd.ownerSid = obj.getProperty(runtime, "ownerSid").asString(runtime).utf8(runtime);
+        sd.groupSid = obj.getProperty(runtime, "groupSid").asString(runtime).utf8(runtime);
+        sd.dacl = JSIConverter<SmbAcl>::fromJSI(runtime, obj.getProperty(runtime, "dacl"));
+
+        return sd;
+    }
+
+    static bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) { return value.isObject(); }
+};
+
+}  // namespace margelo::nitro

package/cpp/shared/connection/ContextRequest.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <atomic>
+#include <cstdint>
+#include <future>
+#include <memory>
+#include <string>
+
+#include "PoolTypes.hpp"
+
+namespace react_native_smb {
+
+class PoolContextHandle;
+
+struct ContextRequest {
+    uint64_t id{0};
+    AcquireMode mode{AcquireMode::Interactive};
+    SmbOperatorKind kind{SmbOperatorKind::Initialize};
+    std::string taskId;
+    std::promise<PoolContextHandle> promise;
+    std::atomic<bool> cancelled{false};
+    std::atomic<bool> fulfilled{false};
+};
+
+using ContextRequestPtr = std::shared_ptr<ContextRequest>;
+
+}  // namespace react_native_smb

package/cpp/shared/connection/ContextRequestQueue.cpp

@@ -0,0 +1,85 @@
+#include "ContextRequestQueue.hpp"
+
+#include "PoolContextHandle.hpp"
+#include "../core/SmbEnums.hpp"
+
+namespace react_native_smb {
+
+size_t ContextRequestQueue::pendingCount() const {
+    return interactivePending_.size() + metadataPending_.size();
+}
+
+void ContextRequestQueue::drainCancelledFromHead(std::deque<ContextRequestPtr>& queue) {
+    while (!queue.empty()) {
+        auto& front = queue.front();
+        if (!front->cancelled.load(std::memory_order_acquire)) break;
+        if (!front->fulfilled.load(std::memory_order_acquire)) {
+            front->fulfilled.store(true, std::memory_order_release);
+            try {
+                front->promise.set_value(PoolContextHandle{});
+            } catch (...) {
+            }
+        }
+        queue.pop_front();
+    }
+}
+
+ContextRequestPtr ContextRequestQueue::enqueue(AcquireMode mode, SmbOperatorKind kind, const std::string& taskId) {
+    auto req = std::make_shared<ContextRequest>();
+    req->id = nextId_++;
+    req->mode = mode;
+    req->kind = kind;
+    req->taskId = taskId;
+
+    auto& queue = (mode == AcquireMode::Interactive) ? interactivePending_ : metadataPending_;
+    queue.push_back(req);
+    return req;
+}
+
+ContextRequestPtr ContextRequestQueue::takeNext() {
+    drainCancelledFromHead(interactivePending_);
+    if (!interactivePending_.empty()) {
+        ContextRequestPtr out = std::move(interactivePending_.front());
+        interactivePending_.pop_front();
+        return out;
+    }
+
+    drainCancelledFromHead(metadataPending_);
+    if (!metadataPending_.empty()) {
+        ContextRequestPtr out = std::move(metadataPending_.front());
+        metadataPending_.pop_front();
+        return out;
+    }
+
+    return nullptr;
+}
+
+void ContextRequestQueue::requeueFront(ContextRequestPtr req) {
+    if (!req) return;
+    auto& queue = (req->mode == AcquireMode::Interactive) ? interactivePending_ : metadataPending_;
+    queue.push_front(std::move(req));
+}
+
+void ContextRequestQueue::cancelForTask(const std::string& taskId) {
+    auto cancelIn = [&](std::deque<ContextRequestPtr>& queue) {
+        for (auto& req : queue) {
+            if (req->taskId != taskId) continue;
+            if (req->fulfilled.load(std::memory_order_acquire)) continue;
+            req->cancelled.store(true, std::memory_order_release);
+            req->fulfilled.store(true, std::memory_order_release);
+            try {
+                req->promise.set_value(PoolContextHandle{});
+            } catch (...) {
+            }
+        }
+    };
+    cancelIn(interactivePending_);
+    cancelIn(metadataPending_);
+}
+
+void ContextRequestQueue::removeCancelledFromHead() {
+    drainCancelledFromHead(interactivePending_);
+    drainCancelledFromHead(metadataPending_);
+}
+
+}  // namespace react_native_smb

package/cpp/shared/connection/ContextRequestQueue.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <cstdint>
+#include <deque>
+#include <memory>
+
+#include "ContextRequest.hpp"
+
+namespace react_native_smb {
+
+class ContextRequestQueue {
+   public:
+    ContextRequestPtr enqueue(AcquireMode mode, SmbOperatorKind kind, const std::string& taskId);
+    ContextRequestPtr takeNext();
+    void requeueFront(ContextRequestPtr req);
+    void removeCancelledFromHead();
+    void cancelForTask(const std::string& taskId);
+
+   private:
+    size_t pendingCount() const;
+    void drainCancelledFromHead(std::deque<ContextRequestPtr>& queue);
+
+    std::deque<ContextRequestPtr> interactivePending_;
+    std::deque<ContextRequestPtr> metadataPending_;
+    uint64_t nextId_{1};
+};
+
+}  // namespace react_native_smb

package/cpp/shared/connection/MetadataContextLease.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <string>
+#include <utility>
+
+#include "../core/SmbEnums.hpp"
+#include "PoolContextHandle.hpp"
+#include "PoolTypes.hpp"
+#include "SmbConnectionPool.hpp"
+
+namespace react_native_smb {
+
+// Holds one metadata pool slot for multiple submitSync calls (e.g. entire copyTreeImpl).
+class MetadataContextLease {
+   public:
+    MetadataContextLease(SmbConnectionPool& pool, SmbOperatorKind kind, const std::string& taskId)
+        : handle_(pool.requestContext(AcquireMode::Metadata, kind, taskId)) {}
+
+    MetadataContextLease(MetadataContextLease&&) = default;
+    MetadataContextLease& operator=(MetadataContextLease&&) = default;
+    MetadataContextLease(const MetadataContextLease&) = delete;
+    MetadataContextLease& operator=(const MetadataContextLease&) = delete;
+
+    template <typename Fn>
+    auto submitSync(Fn&& fn) {
+        return handle_.submitSync(std::forward<Fn>(fn));
+    }
+
+   private:
+    PoolContextHandle handle_;
+};
+
+}  // namespace react_native_smb

package/cpp/shared/connection/PoolContextHandle.cpp

@@ -0,0 +1,35 @@
+#include "PoolContextHandle.hpp"
+
+#include "SmbConnectionPool.hpp"
+
+namespace react_native_smb {
+
+PoolContextHandle::PoolContextHandle(SmbConnectionPool* pool, size_t idx, SmbConnectionManager* conn)
+    : pool_(pool), slotIndex_(idx), conn_(conn) {}
+
+PoolContextHandle::~PoolContextHandle() {
+    if (pool_ && conn_) pool_->releaseContext(*this);
+}
+
+PoolContextHandle::PoolContextHandle(PoolContextHandle&& o) noexcept : pool_(o.pool_), slotIndex_(o.slotIndex_), conn_(o.conn_) {
+    o.pool_ = nullptr;
+    o.conn_ = nullptr;
+}
+
+PoolContextHandle& PoolContextHandle::operator=(PoolContextHandle&& o) noexcept {
+    if (this != &o) {
+        if (pool_ && conn_) pool_->releaseContext(*this);
+        pool_ = o.pool_;
+        slotIndex_ = o.slotIndex_;
+        conn_ = o.conn_;
+        o.pool_ = nullptr;
+        o.conn_ = nullptr;
+    }
+    return *this;
+}
+
+SmbConnectionManager& PoolContextHandle::manager() const { return *conn_; }
+
+smb2_context* PoolContextHandle::ctx() const { return conn_->rawCtx(); }
+
+}  // namespace react_native_smb

package/cpp/shared/connection/PoolContextHandle.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <cstddef>
+#include <ctime>
+#include <type_traits>
+#include <utility>
+
+#include <smb2/smb2.h>
+
+#include "SmbConnection.hpp"
+
+namespace react_native_smb {
+
+class SmbConnectionPool;
+
+class PoolContextHandle {
+   public:
+    PoolContextHandle() = default;
+    PoolContextHandle(SmbConnectionPool* pool, size_t idx, SmbConnectionManager* conn);
+    ~PoolContextHandle();
+
+    PoolContextHandle(PoolContextHandle&& o) noexcept;
+    PoolContextHandle& operator=(PoolContextHandle&& o) noexcept;
+    PoolContextHandle(const PoolContextHandle&) = delete;
+    PoolContextHandle& operator=(const PoolContextHandle&) = delete;
+
+    bool valid() const { return conn_ != nullptr; }
+    size_t slotIndex() const { return slotIndex_; }
+
+    SmbConnectionManager& manager() const;
+    smb2_context* ctx() const;
+
+    template <typename Fn, typename R = std::invoke_result_t<Fn, smb2_context*>>
+    R submitSync(Fn&& fn) {
+        return conn_->submitSync(std::forward<Fn>(fn));
+    }
+
+   private:
+    SmbConnectionPool* pool_{nullptr};
+    size_t slotIndex_{0};
+    SmbConnectionManager* conn_{nullptr};
+};
+
+}  // namespace react_native_smb